# coding: utf-8

"""
TelephonyProvidersEdgeApi.py
Copyright 2016 SmartBear Software

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
"""

from __future__ import absolute_import

import sys
import os

# python 2 and python 3 compatibility library
from six import iteritems

from ..configuration import Configuration
from ..api_client import ApiClient


class TelephonyProvidersEdgeApi(object):
    """
    NOTE: This class is auto generated by the swagger code generator program.
    Do not edit the class manually.
    Ref: https://github.com/swagger-api/swagger-codegen
    """

    def __init__(self, api_client=None):
        config = Configuration()
        if api_client:
            self.api_client = api_client
        else:
            if not config.api_client:
                config.api_client = ApiClient()
            self.api_client = config.api_client

    def delete_providers_edges_certificateauthorities_certificate_id(self, certificate_id, **kwargs):
        """
        Delete a certificate authority.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_providers_edges_certificateauthorities_certificate_id(certificate_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str certificate_id: Certificate ID (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['certificate_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_providers_edges_certificateauthorities_certificate_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'certificate_id' is set
        if ('certificate_id' not in params) or (params['certificate_id'] is None):
            raise ValueError("Missing the required parameter `certificate_id` when calling `delete_providers_edges_certificateauthorities_certificate_id`")

        resource_path = '/api/v2/telephony/providers/edges/certificateauthorities/{certificateId}'.replace('{format}', 'json')
        path_params = {}
        if 'certificate_id' in params:
            path_params['certificateId'] = params['certificate_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='str',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_providers_edges_didpools_didpool_id(self, did_pool_id, **kwargs):
        """
        Delete a DID Pool by ID.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_providers_edges_didpools_didpool_id(did_pool_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str did_pool_id: DID pool ID (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['did_pool_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_providers_edges_didpools_didpool_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'did_pool_id' is set
        if ('did_pool_id' not in params) or (params['did_pool_id'] is None):
            raise ValueError("Missing the required parameter `did_pool_id` when calling `delete_providers_edges_didpools_didpool_id`")

        resource_path = '/api/v2/telephony/providers/edges/didpools/{didPoolId}'.replace('{format}', 'json')
        path_params = {}
        if 'did_pool_id' in params:
            path_params['didPoolId'] = params['did_pool_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='str',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_providers_edges_edge_id(self, edge_id, **kwargs):
        """
        Delete a edge.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_providers_edges_edge_id(edge_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_providers_edges_edge_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `delete_providers_edges_edge_id`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='str',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_providers_edges_edge_id_logicalinterfaces_interface_id(self, edge_id, interface_id, **kwargs):
        """
        Delete an edge logical interface
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_providers_edges_edge_id_logicalinterfaces_interface_id(edge_id, interface_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :param str interface_id: Interface ID (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id', 'interface_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_providers_edges_edge_id_logicalinterfaces_interface_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `delete_providers_edges_edge_id_logicalinterfaces_interface_id`")
        # verify the required parameter 'interface_id' is set
        if ('interface_id' not in params) or (params['interface_id'] is None):
            raise ValueError("Missing the required parameter `interface_id` when calling `delete_providers_edges_edge_id_logicalinterfaces_interface_id`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/logicalinterfaces/{interfaceId}'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']
        if 'interface_id' in params:
            path_params['interfaceId'] = params['interface_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_providers_edges_edge_id_softwareupdate(self, edge_id, **kwargs):
        """
        Cancels any in-progress update for this edge.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_providers_edges_edge_id_softwareupdate(edge_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_providers_edges_edge_id_softwareupdate" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `delete_providers_edges_edge_id_softwareupdate`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/softwareupdate'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='str',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_providers_edges_edgegroups_edgegroup_id(self, edge_group_id, **kwargs):
        """
        Delete an edge group.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_providers_edges_edgegroups_edgegroup_id(edge_group_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_group_id: Edge group ID (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_group_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_providers_edges_edgegroups_edgegroup_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_group_id' is set
        if ('edge_group_id' not in params) or (params['edge_group_id'] is None):
            raise ValueError("Missing the required parameter `edge_group_id` when calling `delete_providers_edges_edgegroups_edgegroup_id`")

        resource_path = '/api/v2/telephony/providers/edges/edgegroups/{edgeGroupId}'.replace('{format}', 'json')
        path_params = {}
        if 'edge_group_id' in params:
            path_params['edgeGroupId'] = params['edge_group_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='str',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_providers_edges_endpoints_endpoint_id(self, endpoint_id, **kwargs):
        """
        Delete endpoint
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_providers_edges_endpoints_endpoint_id(endpoint_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str endpoint_id: Endpoint ID (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['endpoint_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_providers_edges_endpoints_endpoint_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'endpoint_id' is set
        if ('endpoint_id' not in params) or (params['endpoint_id'] is None):
            raise ValueError("Missing the required parameter `endpoint_id` when calling `delete_providers_edges_endpoints_endpoint_id`")

        resource_path = '/api/v2/telephony/providers/edges/endpoints/{endpointId}'.replace('{format}', 'json')
        path_params = {}
        if 'endpoint_id' in params:
            path_params['endpointId'] = params['endpoint_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='str',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_providers_edges_extensionpools_extensionpool_id(self, extension_pool_id, **kwargs):
        """
        Delete an extension pool by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_providers_edges_extensionpools_extensionpool_id(extension_pool_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str extension_pool_id: Extension pool ID (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['extension_pool_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_providers_edges_extensionpools_extensionpool_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'extension_pool_id' is set
        if ('extension_pool_id' not in params) or (params['extension_pool_id'] is None):
            raise ValueError("Missing the required parameter `extension_pool_id` when calling `delete_providers_edges_extensionpools_extensionpool_id`")

        resource_path = '/api/v2/telephony/providers/edges/extensionpools/{extensionPoolId}'.replace('{format}', 'json')
        path_params = {}
        if 'extension_pool_id' in params:
            path_params['extensionPoolId'] = params['extension_pool_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='str',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_providers_edges_outboundroutes_outboundroute_id(self, outbound_route_id, **kwargs):
        """
        Delete Outbound Route
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_providers_edges_outboundroutes_outboundroute_id(outbound_route_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str outbound_route_id: Outbound route ID (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['outbound_route_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_providers_edges_outboundroutes_outboundroute_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'outbound_route_id' is set
        if ('outbound_route_id' not in params) or (params['outbound_route_id'] is None):
            raise ValueError("Missing the required parameter `outbound_route_id` when calling `delete_providers_edges_outboundroutes_outboundroute_id`")

        resource_path = '/api/v2/telephony/providers/edges/outboundroutes/{outboundRouteId}'.replace('{format}', 'json')
        path_params = {}
        if 'outbound_route_id' in params:
            path_params['outboundRouteId'] = params['outbound_route_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='str',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_providers_edges_phonebasesettings_phonebase_id(self, phone_base_id, **kwargs):
        """
        Delete a Phone Base Settings by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_providers_edges_phonebasesettings_phonebase_id(phone_base_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str phone_base_id: Phone base ID (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['phone_base_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_providers_edges_phonebasesettings_phonebase_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'phone_base_id' is set
        if ('phone_base_id' not in params) or (params['phone_base_id'] is None):
            raise ValueError("Missing the required parameter `phone_base_id` when calling `delete_providers_edges_phonebasesettings_phonebase_id`")

        resource_path = '/api/v2/telephony/providers/edges/phonebasesettings/{phoneBaseId}'.replace('{format}', 'json')
        path_params = {}
        if 'phone_base_id' in params:
            path_params['phoneBaseId'] = params['phone_base_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='str',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_providers_edges_phones_phone_id(self, phone_id, **kwargs):
        """
        Delete a Phone by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_providers_edges_phones_phone_id(phone_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str phone_id: Phone ID (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['phone_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_providers_edges_phones_phone_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'phone_id' is set
        if ('phone_id' not in params) or (params['phone_id'] is None):
            raise ValueError("Missing the required parameter `phone_id` when calling `delete_providers_edges_phones_phone_id`")

        resource_path = '/api/v2/telephony/providers/edges/phones/{phoneId}'.replace('{format}', 'json')
        path_params = {}
        if 'phone_id' in params:
            path_params['phoneId'] = params['phone_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='str',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_providers_edges_sites_site_id(self, site_id, **kwargs):
        """
        Delete an ednpoint
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_providers_edges_sites_site_id(site_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str site_id: Site ID (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['site_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_providers_edges_sites_site_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'site_id' is set
        if ('site_id' not in params) or (params['site_id'] is None):
            raise ValueError("Missing the required parameter `site_id` when calling `delete_providers_edges_sites_site_id`")

        resource_path = '/api/v2/telephony/providers/edges/sites/{siteId}'.replace('{format}', 'json')
        path_params = {}
        if 'site_id' in params:
            path_params['siteId'] = params['site_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='str',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_providers_edges_trunkbasesettings_trunkbasesettings_id(self, trunk_base_settings_id, **kwargs):
        """
        Delete a Trunk Base Settings object by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_providers_edges_trunkbasesettings_trunkbasesettings_id(trunk_base_settings_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str trunk_base_settings_id: Trunk Base ID (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['trunk_base_settings_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_providers_edges_trunkbasesettings_trunkbasesettings_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'trunk_base_settings_id' is set
        if ('trunk_base_settings_id' not in params) or (params['trunk_base_settings_id'] is None):
            raise ValueError("Missing the required parameter `trunk_base_settings_id` when calling `delete_providers_edges_trunkbasesettings_trunkbasesettings_id`")

        resource_path = '/api/v2/telephony/providers/edges/trunkbasesettings/{trunkBaseSettingsId}'.replace('{format}', 'json')
        path_params = {}
        if 'trunk_base_settings_id' in params:
            path_params['trunkBaseSettingsId'] = params['trunk_base_settings_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='str',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges(self, **kwargs):
        """
        Get the list of edges.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_size: Page size
        :param int page_number: Page number
        :param str name: Name
        :param str site_id: Filter by site.id
        :param str edge_group_id: Filter by edgeGroup.id
        :param str sort_by: Sort by
        :return: EdgeEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_size', 'page_number', 'name', 'site_id', 'edge_group_id', 'sort_by']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'name' in params:
            query_params['name'] = params['name']
        if 'site_id' in params:
            query_params['site.id'] = params['site_id']
        if 'edge_group_id' in params:
            query_params['edgeGroup.id'] = params['edge_group_id']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='EdgeEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_certificateauthorities(self, **kwargs):
        """
        Get the list of certificate authorities.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_certificateauthorities(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :return: CertificateAuthorityEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_certificateauthorities" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/certificateauthorities'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='CertificateAuthorityEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_certificateauthorities_certificate_id(self, certificate_id, **kwargs):
        """
        Get a certificate authority.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_certificateauthorities_certificate_id(certificate_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str certificate_id: Certificate ID (required)
        :return: DomainCertificateAuthority
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['certificate_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_certificateauthorities_certificate_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'certificate_id' is set
        if ('certificate_id' not in params) or (params['certificate_id'] is None):
            raise ValueError("Missing the required parameter `certificate_id` when calling `get_providers_edges_certificateauthorities_certificate_id`")

        resource_path = '/api/v2/telephony/providers/edges/certificateauthorities/{certificateId}'.replace('{format}', 'json')
        path_params = {}
        if 'certificate_id' in params:
            path_params['certificateId'] = params['certificate_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DomainCertificateAuthority',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_didpools(self, **kwargs):
        """
        Get a listing of DID Pools
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_didpools(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_size: Page size
        :param int page_number: Page number
        :param str sort_by: Sort by
        :return: DIDPoolEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_size', 'page_number', 'sort_by']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_didpools" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/didpools'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DIDPoolEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_didpools_didpool_id(self, did_pool_id, **kwargs):
        """
        Get a DID Pool by ID.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_didpools_didpool_id(did_pool_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str did_pool_id: DID pool ID (required)
        :return: DIDPool
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['did_pool_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_didpools_didpool_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'did_pool_id' is set
        if ('did_pool_id' not in params) or (params['did_pool_id'] is None):
            raise ValueError("Missing the required parameter `did_pool_id` when calling `get_providers_edges_didpools_didpool_id`")

        resource_path = '/api/v2/telephony/providers/edges/didpools/{didPoolId}'.replace('{format}', 'json')
        path_params = {}
        if 'did_pool_id' in params:
            path_params['didPoolId'] = params['did_pool_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DIDPool',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_dids(self, **kwargs):
        """
        Get a listing of DIDs
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_dids(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_size: Page size
        :param int page_number: Page number
        :param str sort_by: Sort by
        :param str sort_order: Sort order
        :param str phone_number: Filter by phoneNumber
        :return: DIDEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_size', 'page_number', 'sort_by', 'sort_order', 'phone_number']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_dids" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/dids'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']
        if 'sort_order' in params:
            query_params['sortOrder'] = params['sort_order']
        if 'phone_number' in params:
            query_params['phoneNumber'] = params['phone_number']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DIDEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_dids_did_id(self, did_id, **kwargs):
        """
        Get a DID by ID.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_dids_did_id(did_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str did_id: DID ID (required)
        :return: DID
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['did_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_dids_did_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'did_id' is set
        if ('did_id' not in params) or (params['did_id'] is None):
            raise ValueError("Missing the required parameter `did_id` when calling `get_providers_edges_dids_did_id`")

        resource_path = '/api/v2/telephony/providers/edges/dids/{didId}'.replace('{format}', 'json')
        path_params = {}
        if 'did_id' in params:
            path_params['didId'] = params['did_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DID',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_edge_id(self, edge_id, **kwargs):
        """
        Get edge.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_edge_id(edge_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :return: Edge
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_edge_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `get_providers_edges_edge_id`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Edge',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_edge_id_lines(self, edge_id, **kwargs):
        """
        Get the list of lines.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_edge_id_lines(edge_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :param int page_size: Page size
        :param int page_number: Page number
        :return: EdgeLineEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id', 'page_size', 'page_number']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_edge_id_lines" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `get_providers_edges_edge_id_lines`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/lines'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='EdgeLineEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_edge_id_lines_line_id(self, edge_id, line_id, **kwargs):
        """
        Get line
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_edge_id_lines_line_id(edge_id, line_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :param str line_id: Line ID (required)
        :return: EdgeLine
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id', 'line_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_edge_id_lines_line_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `get_providers_edges_edge_id_lines_line_id`")
        # verify the required parameter 'line_id' is set
        if ('line_id' not in params) or (params['line_id'] is None):
            raise ValueError("Missing the required parameter `line_id` when calling `get_providers_edges_edge_id_lines_line_id`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/lines/{lineId}'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']
        if 'line_id' in params:
            path_params['lineId'] = params['line_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='EdgeLine',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_edge_id_logicalinterfaces(self, edge_id, **kwargs):
        """
        Get edge logical interfaces.
        Retrieve a list of all configured logical interfaces from a specific edge.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_edge_id_logicalinterfaces(edge_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :return: LogicalInterfaceEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_edge_id_logicalinterfaces" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `get_providers_edges_edge_id_logicalinterfaces`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/logicalinterfaces'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='LogicalInterfaceEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_edge_id_logicalinterfaces_interface_id(self, edge_id, interface_id, **kwargs):
        """
        Get an edge logical interface
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_edge_id_logicalinterfaces_interface_id(edge_id, interface_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :param str interface_id: Interface ID (required)
        :return: DomainLogicalInterface
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id', 'interface_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_edge_id_logicalinterfaces_interface_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `get_providers_edges_edge_id_logicalinterfaces_interface_id`")
        # verify the required parameter 'interface_id' is set
        if ('interface_id' not in params) or (params['interface_id'] is None):
            raise ValueError("Missing the required parameter `interface_id` when calling `get_providers_edges_edge_id_logicalinterfaces_interface_id`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/logicalinterfaces/{interfaceId}'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']
        if 'interface_id' in params:
            path_params['interfaceId'] = params['interface_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DomainLogicalInterface',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_edge_id_logs_jobs_job_id(self, edge_id, job_id, **kwargs):
        """
        Get an Edge logs job.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_edge_id_logs_jobs_job_id(edge_id, job_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :param str job_id: Job ID (required)
        :return: EdgeLogsJob
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id', 'job_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_edge_id_logs_jobs_job_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `get_providers_edges_edge_id_logs_jobs_job_id`")
        # verify the required parameter 'job_id' is set
        if ('job_id' not in params) or (params['job_id'] is None):
            raise ValueError("Missing the required parameter `job_id` when calling `get_providers_edges_edge_id_logs_jobs_job_id`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/logs/jobs/{jobId}'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']
        if 'job_id' in params:
            path_params['jobId'] = params['job_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='EdgeLogsJob',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_edge_id_physicalinterfaces(self, edge_id, **kwargs):
        """
        Retrieve a list of all configured physical interfaces from a specific edge.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_edge_id_physicalinterfaces(edge_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :return: PhysicalInterfaceEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_edge_id_physicalinterfaces" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `get_providers_edges_edge_id_physicalinterfaces`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/physicalinterfaces'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='PhysicalInterfaceEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_edge_id_physicalinterfaces_interface_id(self, edge_id, interface_id, **kwargs):
        """
        Get edge physical interface.
        Retrieve a physical interface from a specific edge.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_edge_id_physicalinterfaces_interface_id(edge_id, interface_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :param str interface_id: Interface ID (required)
        :return: DomainPhysicalInterface
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id', 'interface_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_edge_id_physicalinterfaces_interface_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `get_providers_edges_edge_id_physicalinterfaces_interface_id`")
        # verify the required parameter 'interface_id' is set
        if ('interface_id' not in params) or (params['interface_id'] is None):
            raise ValueError("Missing the required parameter `interface_id` when calling `get_providers_edges_edge_id_physicalinterfaces_interface_id`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/physicalinterfaces/{interfaceId}'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']
        if 'interface_id' in params:
            path_params['interfaceId'] = params['interface_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DomainPhysicalInterface',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_edge_id_softwareupdate(self, edge_id, **kwargs):
        """
        Gets software update status information about any edge.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_edge_id_softwareupdate(edge_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :return: DomainEdgeSoftwareUpdateDto
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_edge_id_softwareupdate" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `get_providers_edges_edge_id_softwareupdate`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/softwareupdate'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DomainEdgeSoftwareUpdateDto',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_edge_id_softwareversions(self, edge_id, **kwargs):
        """
        Gets all the available software versions for this edge.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_edge_id_softwareversions(edge_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :return: DomainEdgeSoftwareVersionDto
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_edge_id_softwareversions" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `get_providers_edges_edge_id_softwareversions`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/softwareversions'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DomainEdgeSoftwareVersionDto',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_edgegroups(self, **kwargs):
        """
        Get the list of edge groups.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_edgegroups(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_size: Page size
        :param int page_number: Page number
        :param str name: Name
        :param str sort_by: Sort by
        :return: EdgeGroupEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_size', 'page_number', 'name', 'sort_by']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_edgegroups" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/edgegroups'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'name' in params:
            query_params['name'] = params['name']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='EdgeGroupEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_edgegroups_edgegroup_id(self, edge_group_id, **kwargs):
        """
        Get edge group.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_edgegroups_edgegroup_id(edge_group_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_group_id: Edge group ID (required)
        :return: EdgeGroup
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_group_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_edgegroups_edgegroup_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_group_id' is set
        if ('edge_group_id' not in params) or (params['edge_group_id'] is None):
            raise ValueError("Missing the required parameter `edge_group_id` when calling `get_providers_edges_edgegroups_edgegroup_id`")

        resource_path = '/api/v2/telephony/providers/edges/edgegroups/{edgeGroupId}'.replace('{format}', 'json')
        path_params = {}
        if 'edge_group_id' in params:
            path_params['edgeGroupId'] = params['edge_group_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='EdgeGroup',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_edgeversionreport(self, **kwargs):
        """
        Get the edge version report.
        The report will not have consistent data about the edge version(s) until all edges have been reset.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_edgeversionreport(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :return: EdgeVersionReport
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_edgeversionreport" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/edgeversionreport'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='EdgeVersionReport',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_endpoints(self, **kwargs):
        """
        Get endpoints
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_endpoints(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_size: Page size
        :param int page_number: Page number
        :param str name: Name
        :param str sort_by: Sort by
        :return: EndpointEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_size', 'page_number', 'name', 'sort_by']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_endpoints" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/endpoints'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'name' in params:
            query_params['name'] = params['name']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='EndpointEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_endpoints_endpoint_id(self, endpoint_id, **kwargs):
        """
        Get endpoint
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_endpoints_endpoint_id(endpoint_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str endpoint_id: Endpoint ID (required)
        :return: Endpoint
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['endpoint_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_endpoints_endpoint_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'endpoint_id' is set
        if ('endpoint_id' not in params) or (params['endpoint_id'] is None):
            raise ValueError("Missing the required parameter `endpoint_id` when calling `get_providers_edges_endpoints_endpoint_id`")

        resource_path = '/api/v2/telephony/providers/edges/endpoints/{endpointId}'.replace('{format}', 'json')
        path_params = {}
        if 'endpoint_id' in params:
            path_params['endpointId'] = params['endpoint_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Endpoint',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_extensionpools(self, **kwargs):
        """
        Get a listing of extension pools
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_extensionpools(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_size: Page size
        :param int page_number: Page number
        :param str sort_by: Sort by
        :param str number: Number
        :return: ExtensionPoolEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_size', 'page_number', 'sort_by', 'number']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_extensionpools" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/extensionpools'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']
        if 'number' in params:
            query_params['number'] = params['number']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='ExtensionPoolEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_extensionpools_extensionpool_id(self, extension_pool_id, **kwargs):
        """
        Get an extension pool by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_extensionpools_extensionpool_id(extension_pool_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str extension_pool_id: Extension pool ID (required)
        :return: ExtensionPool
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['extension_pool_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_extensionpools_extensionpool_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'extension_pool_id' is set
        if ('extension_pool_id' not in params) or (params['extension_pool_id'] is None):
            raise ValueError("Missing the required parameter `extension_pool_id` when calling `get_providers_edges_extensionpools_extensionpool_id`")

        resource_path = '/api/v2/telephony/providers/edges/extensionpools/{extensionPoolId}'.replace('{format}', 'json')
        path_params = {}
        if 'extension_pool_id' in params:
            path_params['extensionPoolId'] = params['extension_pool_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='ExtensionPool',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_extensions(self, **kwargs):
        """
        Get a listing of extensions
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_extensions(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_size: Page size
        :param int page_number: Page number
        :param str sort_by: Sort by
        :param str sort_order: Sort order
        :param str number: Filter by number
        :return: ExtensionEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_size', 'page_number', 'sort_by', 'sort_order', 'number']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_extensions" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/extensions'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']
        if 'sort_order' in params:
            query_params['sortOrder'] = params['sort_order']
        if 'number' in params:
            query_params['number'] = params['number']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='ExtensionEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_extensions_extension_id(self, extension_id, **kwargs):
        """
        Get an extension by ID.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_extensions_extension_id(extension_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str extension_id: Extension ID (required)
        :return: Extension
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['extension_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_extensions_extension_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'extension_id' is set
        if ('extension_id' not in params) or (params['extension_id'] is None):
            raise ValueError("Missing the required parameter `extension_id` when calling `get_providers_edges_extensions_extension_id`")

        resource_path = '/api/v2/telephony/providers/edges/extensions/{extensionId}'.replace('{format}', 'json')
        path_params = {}
        if 'extension_id' in params:
            path_params['extensionId'] = params['extension_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Extension',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_linebasesettings(self, **kwargs):
        """
        Get a listing of line base settings objects
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_linebasesettings(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_number: Page number
        :param int page_size: Page size
        :param str sort_by: Value by which to sort
        :param str sort_order: Sort order
        :return: LineBaseEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_number', 'page_size', 'sort_by', 'sort_order']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_linebasesettings" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/linebasesettings'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']
        if 'sort_order' in params:
            query_params['sortOrder'] = params['sort_order']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='LineBaseEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_linebasesettings_linebase_id(self, line_base_id, **kwargs):
        """
        Get a line base settings object by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_linebasesettings_linebase_id(line_base_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str line_base_id: Line base ID (required)
        :return: LineBase
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['line_base_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_linebasesettings_linebase_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'line_base_id' is set
        if ('line_base_id' not in params) or (params['line_base_id'] is None):
            raise ValueError("Missing the required parameter `line_base_id` when calling `get_providers_edges_linebasesettings_linebase_id`")

        resource_path = '/api/v2/telephony/providers/edges/linebasesettings/{lineBaseId}'.replace('{format}', 'json')
        path_params = {}
        if 'line_base_id' in params:
            path_params['lineBaseId'] = params['line_base_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='LineBase',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_lines(self, **kwargs):
        """
        Get a list of Lines
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_lines(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_size: Page size
        :param int page_number: Page number
        :param str name: Name
        :param str sort_by: Value by which to sort
        :param list[str] expand: Fields to expand in the response, comma-separated
        :return: LineEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_size', 'page_number', 'name', 'sort_by', 'expand']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_lines" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/lines'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'name' in params:
            query_params['name'] = params['name']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']
        if 'expand' in params:
            query_params['expand'] = params['expand']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='LineEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_lines_line_id(self, line_id, **kwargs):
        """
        Get a Line by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_lines_line_id(line_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str line_id: Line ID (required)
        :return: Line
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['line_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_lines_line_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'line_id' is set
        if ('line_id' not in params) or (params['line_id'] is None):
            raise ValueError("Missing the required parameter `line_id` when calling `get_providers_edges_lines_line_id`")

        resource_path = '/api/v2/telephony/providers/edges/lines/{lineId}'.replace('{format}', 'json')
        path_params = {}
        if 'line_id' in params:
            path_params['lineId'] = params['line_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Line',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_lines_template(self, line_base_settings_id, **kwargs):
        """
        Get a Line instance template based on a Line Base Settings object. This object can then be modified and saved as a new Line instance
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_lines_template(line_base_settings_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str line_base_settings_id: The id of a Line Base Settings object upon which to base this Line (required)
        :return: Line
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['line_base_settings_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_lines_template" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'line_base_settings_id' is set
        if ('line_base_settings_id' not in params) or (params['line_base_settings_id'] is None):
            raise ValueError("Missing the required parameter `line_base_settings_id` when calling `get_providers_edges_lines_template`")

        resource_path = '/api/v2/telephony/providers/edges/lines/template'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'line_base_settings_id' in params:
            query_params['lineBaseSettingsId'] = params['line_base_settings_id']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Line',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_outboundroutes(self, **kwargs):
        """
        Get outbound routes
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_outboundroutes(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_size: Page size
        :param int page_number: Page number
        :param str name: Name
        :param str site_id: Filter by site.id
        :param str sort_by: Sort by
        :return: OutboundRouteEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_size', 'page_number', 'name', 'site_id', 'sort_by']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_outboundroutes" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/outboundroutes'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'name' in params:
            query_params['name'] = params['name']
        if 'site_id' in params:
            query_params['site.id'] = params['site_id']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='OutboundRouteEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_outboundroutes_outboundroute_id(self, outbound_route_id, **kwargs):
        """
        Get outbound route
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_outboundroutes_outboundroute_id(outbound_route_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str outbound_route_id: Outbound route ID (required)
        :return: OutboundRoute
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['outbound_route_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_outboundroutes_outboundroute_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'outbound_route_id' is set
        if ('outbound_route_id' not in params) or (params['outbound_route_id'] is None):
            raise ValueError("Missing the required parameter `outbound_route_id` when calling `get_providers_edges_outboundroutes_outboundroute_id`")

        resource_path = '/api/v2/telephony/providers/edges/outboundroutes/{outboundRouteId}'.replace('{format}', 'json')
        path_params = {}
        if 'outbound_route_id' in params:
            path_params['outboundRouteId'] = params['outbound_route_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='OutboundRoute',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_phonebasesettings(self, **kwargs):
        """
        Get a list of Phone Base Settings objects
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_phonebasesettings(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_number: Page number
        :param int page_size: Page size
        :param str sort_by: Value by which to sort
        :param str sort_order: Sort order
        :return: PhoneBaseEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_number', 'page_size', 'sort_by', 'sort_order']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_phonebasesettings" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/phonebasesettings'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']
        if 'sort_order' in params:
            query_params['sortOrder'] = params['sort_order']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='PhoneBaseEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_phonebasesettings_availablemetabases(self, **kwargs):
        """
        Get a list of available makes and models to create a new Phone Base Settings
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_phonebasesettings_availablemetabases(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_size: Page size
        :param int page_number: Page number
        :return: PhoneMetaBaseEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_size', 'page_number']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_phonebasesettings_availablemetabases" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/phonebasesettings/availablemetabases'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='PhoneMetaBaseEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_phonebasesettings_phonebase_id(self, phone_base_id, **kwargs):
        """
        Get a Phone Base Settings object by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_phonebasesettings_phonebase_id(phone_base_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str phone_base_id: Phone base ID (required)
        :return: PhoneBase
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['phone_base_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_phonebasesettings_phonebase_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'phone_base_id' is set
        if ('phone_base_id' not in params) or (params['phone_base_id'] is None):
            raise ValueError("Missing the required parameter `phone_base_id` when calling `get_providers_edges_phonebasesettings_phonebase_id`")

        resource_path = '/api/v2/telephony/providers/edges/phonebasesettings/{phoneBaseId}'.replace('{format}', 'json')
        path_params = {}
        if 'phone_base_id' in params:
            path_params['phoneBaseId'] = params['phone_base_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='PhoneBase',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_phonebasesettings_template(self, phone_metabase_id, **kwargs):
        """
        Get a Phone Base Settings instance template from a given make and model. This object can then be modified and saved as a new Phone Base Settings instance
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_phonebasesettings_template(phone_metabase_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str phone_metabase_id: The id of a metabase object upon which to base this Phone Base Settings (required)
        :return: PhoneBase
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['phone_metabase_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_phonebasesettings_template" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'phone_metabase_id' is set
        if ('phone_metabase_id' not in params) or (params['phone_metabase_id'] is None):
            raise ValueError("Missing the required parameter `phone_metabase_id` when calling `get_providers_edges_phonebasesettings_template`")

        resource_path = '/api/v2/telephony/providers/edges/phonebasesettings/template'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'phone_metabase_id' in params:
            query_params['phoneMetabaseId'] = params['phone_metabase_id']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='PhoneBase',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_phones(self, **kwargs):
        """
        Get a list of Phone Instances
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_phones(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_number: Page number
        :param int page_size: Page size
        :param str sort_by: Value by which to sort
        :param str sort_order: Sort order
        :param str site_id: Filter by site.id
        :param str phone_base_settings_id: Filter by phoneBaseSettings.id
        :param str phone_hardware_id: Filter by phone_hardwareId
        :param list[str] expand: Fields to expand in the response, comma-separated
        :param list[str] fields: Fields under properties to get, comma-separated
        :return: PhoneEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_number', 'page_size', 'sort_by', 'sort_order', 'site_id', 'phone_base_settings_id', 'phone_hardware_id', 'expand', 'fields']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_phones" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/phones'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']
        if 'sort_order' in params:
            query_params['sortOrder'] = params['sort_order']
        if 'site_id' in params:
            query_params['site.id'] = params['site_id']
        if 'phone_base_settings_id' in params:
            query_params['phoneBaseSettings.id'] = params['phone_base_settings_id']
        if 'phone_hardware_id' in params:
            query_params['phone_hardwareId'] = params['phone_hardware_id']
        if 'expand' in params:
            query_params['expand'] = params['expand']
        if 'fields' in params:
            query_params['fields'] = params['fields']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='PhoneEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_phones_phone_id(self, phone_id, **kwargs):
        """
        Get a Phone by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_phones_phone_id(phone_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str phone_id: Phone ID (required)
        :return: Phone
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['phone_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_phones_phone_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'phone_id' is set
        if ('phone_id' not in params) or (params['phone_id'] is None):
            raise ValueError("Missing the required parameter `phone_id` when calling `get_providers_edges_phones_phone_id`")

        resource_path = '/api/v2/telephony/providers/edges/phones/{phoneId}'.replace('{format}', 'json')
        path_params = {}
        if 'phone_id' in params:
            path_params['phoneId'] = params['phone_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Phone',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_phones_template(self, phone_base_settings_id, **kwargs):
        """
        Get a Phone instance template based on a Phone Base Settings object. This object can then be modified and saved as a new Phone instance
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_phones_template(phone_base_settings_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str phone_base_settings_id: The id of a Phone Base Settings object upon which to base this Phone (required)
        :return: Phone
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['phone_base_settings_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_phones_template" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'phone_base_settings_id' is set
        if ('phone_base_settings_id' not in params) or (params['phone_base_settings_id'] is None):
            raise ValueError("Missing the required parameter `phone_base_settings_id` when calling `get_providers_edges_phones_template`")

        resource_path = '/api/v2/telephony/providers/edges/phones/template'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'phone_base_settings_id' in params:
            query_params['phoneBaseSettingsId'] = params['phone_base_settings_id']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Phone',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_sites(self, **kwargs):
        """
        Get the list of sites.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_sites(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_size: Page size
        :param int page_number: Page number
        :param str sort_by: Sort by
        :param str sort_order: Sort order
        :param str name: Name
        :param str location_id: Location Id
        :return: SiteEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_size', 'page_number', 'sort_by', 'sort_order', 'name', 'location_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_sites" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/sites'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']
        if 'sort_order' in params:
            query_params['sortOrder'] = params['sort_order']
        if 'name' in params:
            query_params['name'] = params['name']
        if 'location_id' in params:
            query_params['location.id'] = params['location_id']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SiteEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_sites_site_id(self, site_id, **kwargs):
        """
        Get endpoint.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_sites_site_id(site_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str site_id: Site ID (required)
        :return: Site
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['site_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_sites_site_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'site_id' is set
        if ('site_id' not in params) or (params['site_id'] is None):
            raise ValueError("Missing the required parameter `site_id` when calling `get_providers_edges_sites_site_id`")

        resource_path = '/api/v2/telephony/providers/edges/sites/{siteId}'.replace('{format}', 'json')
        path_params = {}
        if 'site_id' in params:
            path_params['siteId'] = params['site_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Site',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_sites_site_id_numberplans(self, site_id, **kwargs):
        """
        Get the list of Number Plans for this Site.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_sites_site_id_numberplans(site_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str site_id: Site ID (required)
        :return: list[NumberPlan]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['site_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_sites_site_id_numberplans" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'site_id' is set
        if ('site_id' not in params) or (params['site_id'] is None):
            raise ValueError("Missing the required parameter `site_id` when calling `get_providers_edges_sites_site_id_numberplans`")

        resource_path = '/api/v2/telephony/providers/edges/sites/{siteId}/numberplans'.replace('{format}', 'json')
        path_params = {}
        if 'site_id' in params:
            path_params['siteId'] = params['site_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='list[NumberPlan]',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_sites_site_id_numberplans_classifications(self, site_id, **kwargs):
        """
        Get a list of Classifications for this Site
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_sites_site_id_numberplans_classifications(site_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str site_id: Site ID (required)
        :param str classification: Classification
        :return: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['site_id', 'classification']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_sites_site_id_numberplans_classifications" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'site_id' is set
        if ('site_id' not in params) or (params['site_id'] is None):
            raise ValueError("Missing the required parameter `site_id` when calling `get_providers_edges_sites_site_id_numberplans_classifications`")

        resource_path = '/api/v2/telephony/providers/edges/sites/{siteId}/numberplans/classifications'.replace('{format}', 'json')
        path_params = {}
        if 'site_id' in params:
            path_params['siteId'] = params['site_id']

        query_params = {}
        if 'classification' in params:
            query_params['classification'] = params['classification']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='list[str]',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_sites_site_id_numberplans_numberplan_id(self, site_id, number_plan_id, **kwargs):
        """
        Get a Number Plan by ID.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_sites_site_id_numberplans_numberplan_id(site_id, number_plan_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str site_id: Site ID (required)
        :param str number_plan_id: Number Plan ID (required)
        :return: NumberPlan
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['site_id', 'number_plan_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_sites_site_id_numberplans_numberplan_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'site_id' is set
        if ('site_id' not in params) or (params['site_id'] is None):
            raise ValueError("Missing the required parameter `site_id` when calling `get_providers_edges_sites_site_id_numberplans_numberplan_id`")
        # verify the required parameter 'number_plan_id' is set
        if ('number_plan_id' not in params) or (params['number_plan_id'] is None):
            raise ValueError("Missing the required parameter `number_plan_id` when calling `get_providers_edges_sites_site_id_numberplans_numberplan_id`")

        resource_path = '/api/v2/telephony/providers/edges/sites/{siteId}/numberplans/{numberPlanId}'.replace('{format}', 'json')
        path_params = {}
        if 'site_id' in params:
            path_params['siteId'] = params['site_id']
        if 'number_plan_id' in params:
            path_params['numberPlanId'] = params['number_plan_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='NumberPlan',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_timezones(self, **kwargs):
        """
        Get a list of Edge-compatible time zones
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_timezones(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_size: Page size
        :param int page_number: Page number
        :return: TimeZoneEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_size', 'page_number']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_timezones" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/timezones'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='TimeZoneEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_trunkbasesettings(self, **kwargs):
        """
        Get Trunk Base Settings listing
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_trunkbasesettings(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_number: Page number
        :param int page_size: Page size
        :param str sort_by: Value by which to sort
        :param str sort_order: Sort order
        :return: TrunkBase
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_number', 'page_size', 'sort_by', 'sort_order']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_trunkbasesettings" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/trunkbasesettings'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']
        if 'sort_order' in params:
            query_params['sortOrder'] = params['sort_order']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='TrunkBase',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_trunkbasesettings_availablemetabases(self, **kwargs):
        """
        Get a list of available makes and models to create a new Trunk Base Settings
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_trunkbasesettings_availablemetabases(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str type: 
        :param int page_size: 
        :param int page_number: 
        :return: TrunkMetabaseEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['type', 'page_size', 'page_number']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_trunkbasesettings_availablemetabases" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/trunkbasesettings/availablemetabases'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'type' in params:
            query_params['type'] = params['type']
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='TrunkMetabaseEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_trunkbasesettings_template(self, trunk_metabase_id, **kwargs):
        """
        Get a Trunk Base Settings instance template from a given make and model. This object can then be modified and saved as a new Trunk Base Settings instance
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_trunkbasesettings_template(trunk_metabase_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str trunk_metabase_id: The id of a metabase object upon which to base this Trunk Base Settings (required)
        :return: TrunkBase
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['trunk_metabase_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_trunkbasesettings_template" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'trunk_metabase_id' is set
        if ('trunk_metabase_id' not in params) or (params['trunk_metabase_id'] is None):
            raise ValueError("Missing the required parameter `trunk_metabase_id` when calling `get_providers_edges_trunkbasesettings_template`")

        resource_path = '/api/v2/telephony/providers/edges/trunkbasesettings/template'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'trunk_metabase_id' in params:
            query_params['trunkMetabaseId'] = params['trunk_metabase_id']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='TrunkBase',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_trunkbasesettings_trunkbasesettings_id(self, trunk_base_settings_id, **kwargs):
        """
        Get a Trunk Base Settings object by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_trunkbasesettings_trunkbasesettings_id(trunk_base_settings_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str trunk_base_settings_id: Trunk Base ID (required)
        :return: TrunkBase
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['trunk_base_settings_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_trunkbasesettings_trunkbasesettings_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'trunk_base_settings_id' is set
        if ('trunk_base_settings_id' not in params) or (params['trunk_base_settings_id'] is None):
            raise ValueError("Missing the required parameter `trunk_base_settings_id` when calling `get_providers_edges_trunkbasesettings_trunkbasesettings_id`")

        resource_path = '/api/v2/telephony/providers/edges/trunkbasesettings/{trunkBaseSettingsId}'.replace('{format}', 'json')
        path_params = {}
        if 'trunk_base_settings_id' in params:
            path_params['trunkBaseSettingsId'] = params['trunk_base_settings_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='TrunkBase',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_trunks(self, **kwargs):
        """
        Get the list of available trunks.
        Trunks are created by assigning trunk base settings to an Edge or Edge Group.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_trunks(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_number: Page number
        :param int page_size: Page size
        :param str sort_by: Value by which to sort
        :param str sort_order: Sort order
        :param str edge_id: Filter by Edge Ids
        :param str trunk_base_id: Filter by Trunk Base Ids
        :param str trunk_type: Filter by a Trunk type
        :return: TrunkEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_number', 'page_size', 'sort_by', 'sort_order', 'edge_id', 'trunk_base_id', 'trunk_type']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_trunks" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/trunks'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'sort_by' in params:
            query_params['sortBy'] = params['sort_by']
        if 'sort_order' in params:
            query_params['sortOrder'] = params['sort_order']
        if 'edge_id' in params:
            query_params['edge.id'] = params['edge_id']
        if 'trunk_base_id' in params:
            query_params['trunkBase.id'] = params['trunk_base_id']
        if 'trunk_type' in params:
            query_params['trunkType'] = params['trunk_type']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='TrunkEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_providers_edges_trunks_trunk_id(self, trunk_id, **kwargs):
        """
        Get a Trunk by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_providers_edges_trunks_trunk_id(trunk_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str trunk_id: Trunk ID (required)
        :return: Trunk
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['trunk_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_providers_edges_trunks_trunk_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'trunk_id' is set
        if ('trunk_id' not in params) or (params['trunk_id'] is None):
            raise ValueError("Missing the required parameter `trunk_id` when calling `get_providers_edges_trunks_trunk_id`")

        resource_path = '/api/v2/telephony/providers/edges/trunks/{trunkId}'.replace('{format}', 'json')
        path_params = {}
        if 'trunk_id' in params:
            path_params['trunkId'] = params['trunk_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Trunk',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_schemas_edges_vnext(self, **kwargs):
        """
        Lists available schema categories
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_schemas_edges_vnext(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param int page_size: Page size
        :param int page_number: Page number
        :return: SchemaCategoryEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['page_size', 'page_number']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_schemas_edges_vnext" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/configuration/schemas/edges/vnext'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SchemaCategoryEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_schemas_edges_vnext_schemacategory(self, schema_category, **kwargs):
        """
        List schemas of a specific category
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_schemas_edges_vnext_schemacategory(schema_category, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str schema_category: Schema category (required)
        :param int page_size: Page size
        :param int page_number: Page number
        :return: SchemaReferenceEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['schema_category', 'page_size', 'page_number']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_schemas_edges_vnext_schemacategory" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'schema_category' is set
        if ('schema_category' not in params) or (params['schema_category'] is None):
            raise ValueError("Missing the required parameter `schema_category` when calling `get_schemas_edges_vnext_schemacategory`")

        resource_path = '/api/v2/configuration/schemas/edges/vnext/{schemaCategory}'.replace('{format}', 'json')
        path_params = {}
        if 'schema_category' in params:
            path_params['schemaCategory'] = params['schema_category']

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SchemaReferenceEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_schemas_edges_vnext_schemacategory_schematype(self, schema_category, schema_type, **kwargs):
        """
        List schemas of a specific category
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_schemas_edges_vnext_schemacategory_schematype(schema_category, schema_type, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str schema_category: Schema category (required)
        :param str schema_type: Schema type (required)
        :param int page_size: Page size
        :param int page_number: Page number
        :return: SchemaReferenceEntityListing
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['schema_category', 'schema_type', 'page_size', 'page_number']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_schemas_edges_vnext_schemacategory_schematype" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'schema_category' is set
        if ('schema_category' not in params) or (params['schema_category'] is None):
            raise ValueError("Missing the required parameter `schema_category` when calling `get_schemas_edges_vnext_schemacategory_schematype`")
        # verify the required parameter 'schema_type' is set
        if ('schema_type' not in params) or (params['schema_type'] is None):
            raise ValueError("Missing the required parameter `schema_type` when calling `get_schemas_edges_vnext_schemacategory_schematype`")

        resource_path = '/api/v2/configuration/schemas/edges/vnext/{schemaCategory}/{schemaType}'.replace('{format}', 'json')
        path_params = {}
        if 'schema_category' in params:
            path_params['schemaCategory'] = params['schema_category']
        if 'schema_type' in params:
            path_params['schemaType'] = params['schema_type']

        query_params = {}
        if 'page_size' in params:
            query_params['pageSize'] = params['page_size']
        if 'page_number' in params:
            query_params['pageNumber'] = params['page_number']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SchemaReferenceEntityListing',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_schemas_edges_vnext_schemacategory_schematype_schema_id(self, schema_category, schema_type, schema_id, **kwargs):
        """
        Get a json schema
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_schemas_edges_vnext_schemacategory_schematype_schema_id(schema_category, schema_type, schema_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str schema_category: Schema category (required)
        :param str schema_type: Schema type (required)
        :param str schema_id: Schema ID (required)
        :return: Organization
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['schema_category', 'schema_type', 'schema_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_schemas_edges_vnext_schemacategory_schematype_schema_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'schema_category' is set
        if ('schema_category' not in params) or (params['schema_category'] is None):
            raise ValueError("Missing the required parameter `schema_category` when calling `get_schemas_edges_vnext_schemacategory_schematype_schema_id`")
        # verify the required parameter 'schema_type' is set
        if ('schema_type' not in params) or (params['schema_type'] is None):
            raise ValueError("Missing the required parameter `schema_type` when calling `get_schemas_edges_vnext_schemacategory_schematype_schema_id`")
        # verify the required parameter 'schema_id' is set
        if ('schema_id' not in params) or (params['schema_id'] is None):
            raise ValueError("Missing the required parameter `schema_id` when calling `get_schemas_edges_vnext_schemacategory_schematype_schema_id`")

        resource_path = '/api/v2/configuration/schemas/edges/vnext/{schemaCategory}/{schemaType}/{schemaId}'.replace('{format}', 'json')
        path_params = {}
        if 'schema_category' in params:
            path_params['schemaCategory'] = params['schema_category']
        if 'schema_type' in params:
            path_params['schemaType'] = params['schema_type']
        if 'schema_id' in params:
            path_params['schemaId'] = params['schema_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Organization',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_schemas_edges_vnext_schemacategory_schematype_schema_id_extensiontype_metadata_id(self, schema_category, schema_type, schema_id, extension_type, metadata_id, **kwargs):
        """
        Get metadata for a schema
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_schemas_edges_vnext_schemacategory_schematype_schema_id_extensiontype_metadata_id(schema_category, schema_type, schema_id, extension_type, metadata_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str schema_category: Schema category (required)
        :param str schema_type: Schema type (required)
        :param str schema_id: Schema ID (required)
        :param str extension_type: extension (required)
        :param str metadata_id: Metadata ID (required)
        :param str type: Type
        :return: Organization
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['schema_category', 'schema_type', 'schema_id', 'extension_type', 'metadata_id', 'type']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_schemas_edges_vnext_schemacategory_schematype_schema_id_extensiontype_metadata_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'schema_category' is set
        if ('schema_category' not in params) or (params['schema_category'] is None):
            raise ValueError("Missing the required parameter `schema_category` when calling `get_schemas_edges_vnext_schemacategory_schematype_schema_id_extensiontype_metadata_id`")
        # verify the required parameter 'schema_type' is set
        if ('schema_type' not in params) or (params['schema_type'] is None):
            raise ValueError("Missing the required parameter `schema_type` when calling `get_schemas_edges_vnext_schemacategory_schematype_schema_id_extensiontype_metadata_id`")
        # verify the required parameter 'schema_id' is set
        if ('schema_id' not in params) or (params['schema_id'] is None):
            raise ValueError("Missing the required parameter `schema_id` when calling `get_schemas_edges_vnext_schemacategory_schematype_schema_id_extensiontype_metadata_id`")
        # verify the required parameter 'extension_type' is set
        if ('extension_type' not in params) or (params['extension_type'] is None):
            raise ValueError("Missing the required parameter `extension_type` when calling `get_schemas_edges_vnext_schemacategory_schematype_schema_id_extensiontype_metadata_id`")
        # verify the required parameter 'metadata_id' is set
        if ('metadata_id' not in params) or (params['metadata_id'] is None):
            raise ValueError("Missing the required parameter `metadata_id` when calling `get_schemas_edges_vnext_schemacategory_schematype_schema_id_extensiontype_metadata_id`")

        resource_path = '/api/v2/configuration/schemas/edges/vnext/{schemaCategory}/{schemaType}/{schemaId}/{extensionType}/{metadataId}'.replace('{format}', 'json')
        path_params = {}
        if 'schema_category' in params:
            path_params['schemaCategory'] = params['schema_category']
        if 'schema_type' in params:
            path_params['schemaType'] = params['schema_type']
        if 'schema_id' in params:
            path_params['schemaId'] = params['schema_id']
        if 'extension_type' in params:
            path_params['extensionType'] = params['extension_type']
        if 'metadata_id' in params:
            path_params['metadataId'] = params['metadata_id']

        query_params = {}
        if 'type' in params:
            query_params['type'] = params['type']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Organization',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges(self, **kwargs):
        """
        Create a edge.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param Edge body: Edge
        :return: Edge
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Edge',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_addressvalidation(self, **kwargs):
        """
        Validates a street address
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_addressvalidation(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ValidateAddressRequest body: 
        :return: ValidateAddressResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_addressvalidation" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/addressvalidation'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='ValidateAddressResponse',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_certificateauthorities(self, **kwargs):
        """
        Create a certificate authority.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_certificateauthorities(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param DomainCertificateAuthority body: CertificateAuthority
        :return: DomainCertificateAuthority
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_certificateauthorities" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/certificateauthorities'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DomainCertificateAuthority',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_didpools(self, **kwargs):
        """
        Create a new DID pool
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_didpools(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param DIDPool body: 
        :return: DIDPool
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_didpools" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/didpools'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DIDPool',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_edge_id_logicalinterfaces(self, edge_id, **kwargs):
        """
        Create an edge logical interface.
        Create

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_edge_id_logicalinterfaces(edge_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :param DomainLogicalInterface body: 
        :return: DomainLogicalInterface
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_edge_id_logicalinterfaces" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `post_providers_edges_edge_id_logicalinterfaces`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/logicalinterfaces'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DomainLogicalInterface',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_edge_id_logs_jobs(self, edge_id, **kwargs):
        """
        Create a job to upload a list of Edge logs.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_edge_id_logs_jobs(edge_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :param EdgeLogsJobRequest body: EdgeLogsJobRequest
        :return: EdgeLogsJobResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_edge_id_logs_jobs" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `post_providers_edges_edge_id_logs_jobs`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/logs/jobs'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='EdgeLogsJobResponse',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_edge_id_logs_jobs_job_id_upload(self, edge_id, job_id, **kwargs):
        """
        Request that the specified fileIds be uploaded from the Edge.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_edge_id_logs_jobs_job_id_upload(edge_id, job_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :param str job_id: Job ID (required)
        :param EdgeLogsJobUploadRequest body: 
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id', 'job_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_edge_id_logs_jobs_job_id_upload" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `post_providers_edges_edge_id_logs_jobs_job_id_upload`")
        # verify the required parameter 'job_id' is set
        if ('job_id' not in params) or (params['job_id'] is None):
            raise ValueError("Missing the required parameter `job_id` when calling `post_providers_edges_edge_id_logs_jobs_job_id_upload`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/logs/jobs/{jobId}/upload'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']
        if 'job_id' in params:
            path_params['jobId'] = params['job_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_edge_id_reboot(self, edge_id, **kwargs):
        """
        Reboot an Edge
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_edge_id_reboot(edge_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_edge_id_reboot" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `post_providers_edges_edge_id_reboot`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/reboot'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='str',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_edge_id_softwareupdate(self, edge_id, **kwargs):
        """
        Starts a software update for this edge.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_edge_id_softwareupdate(edge_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :param DomainEdgeSoftwareUpdateDto body: 
        :return: DomainEdgeSoftwareUpdateDto
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_edge_id_softwareupdate" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `post_providers_edges_edge_id_softwareupdate`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/softwareupdate'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DomainEdgeSoftwareUpdateDto',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_edge_id_unpair(self, edge_id, **kwargs):
        """
        Unpair an Edge
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_edge_id_unpair(edge_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge Id (required)
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_edge_id_unpair" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `post_providers_edges_edge_id_unpair`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/unpair'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='str',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_edgegroups(self, **kwargs):
        """
        Create an edge group.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_edgegroups(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param EdgeGroup body: EdgeGroup
        :return: EdgeGroup
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_edgegroups" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/edgegroups'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='EdgeGroup',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_endpoints(self, **kwargs):
        """
        Create endpoint
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_endpoints(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param Endpoint body: EndpointTemplate
        :return: Endpoint
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_endpoints" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/endpoints'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Endpoint',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_extensionpools(self, **kwargs):
        """
        Create a new extension pool
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_extensionpools(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param ExtensionPool body: ExtensionPool
        :return: Extension
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_extensionpools" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/extensionpools'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Extension',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_outboundroutes(self, **kwargs):
        """
        Create outbound rule
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_outboundroutes(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param OutboundRoute body: OutboundRoute
        :return: OutboundRoute
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_outboundroutes" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/outboundroutes'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='OutboundRoute',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_phonebasesettings(self, **kwargs):
        """
        Create a new Phone Base Settings object
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_phonebasesettings(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param PhoneBase body: 
        :return: PhoneBase
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_phonebasesettings" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/phonebasesettings'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='PhoneBase',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_phones(self, **kwargs):
        """
        Create a new Phone
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_phones(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param Phone body: 
        :return: Phone
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_phones" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/phones'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Phone',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_phones_phone_id_reboot(self, phone_id, **kwargs):
        """
        Reboot a Phone
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_phones_phone_id_reboot(phone_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str phone_id: Phone Id (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['phone_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_phones_phone_id_reboot" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'phone_id' is set
        if ('phone_id' not in params) or (params['phone_id'] is None):
            raise ValueError("Missing the required parameter `phone_id` when calling `post_providers_edges_phones_phone_id_reboot`")

        resource_path = '/api/v2/telephony/providers/edges/phones/{phoneId}/reboot'.replace('{format}', 'json')
        path_params = {}
        if 'phone_id' in params:
            path_params['phoneId'] = params['phone_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_phones_reboot(self, **kwargs):
        """
        Reboot Multiple Phones
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_phones_reboot(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param PhonesReboot body: body
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_phones_reboot" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/phones/reboot'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_sites(self, **kwargs):
        """
        Create a endpoint.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_sites(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param Site body: Site
        :return: Site
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_sites" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/sites'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Site',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_sites_site_id_rebalance(self, site_id, **kwargs):
        """
        Triggers the rebalance operation.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_sites_site_id_rebalance(site_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str site_id: Site ID (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['site_id']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_sites_site_id_rebalance" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'site_id' is set
        if ('site_id' not in params) or (params['site_id'] is None):
            raise ValueError("Missing the required parameter `site_id` when calling `post_providers_edges_sites_site_id_rebalance`")

        resource_path = '/api/v2/telephony/providers/edges/sites/{siteId}/rebalance'.replace('{format}', 'json')
        path_params = {}
        if 'site_id' in params:
            path_params['siteId'] = params['site_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def post_providers_edges_trunkbasesettings(self, **kwargs):
        """
        Create a Trunk Base Settings object
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.post_providers_edges_trunkbasesettings(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param TrunkBase body: 
        :return: TrunkBase
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method post_providers_edges_trunkbasesettings" % key
                )
            params[key] = val
        del params['kwargs']


        resource_path = '/api/v2/telephony/providers/edges/trunkbasesettings'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='TrunkBase',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_certificateauthorities_certificate_id(self, certificate_id, **kwargs):
        """
        Update a certificate authority.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_certificateauthorities_certificate_id(certificate_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str certificate_id: Certificate ID (required)
        :param DomainCertificateAuthority body: 
        :return: DomainCertificateAuthority
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['certificate_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_certificateauthorities_certificate_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'certificate_id' is set
        if ('certificate_id' not in params) or (params['certificate_id'] is None):
            raise ValueError("Missing the required parameter `certificate_id` when calling `put_providers_edges_certificateauthorities_certificate_id`")

        resource_path = '/api/v2/telephony/providers/edges/certificateauthorities/{certificateId}'.replace('{format}', 'json')
        path_params = {}
        if 'certificate_id' in params:
            path_params['certificateId'] = params['certificate_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DomainCertificateAuthority',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_didpools_didpool_id(self, did_pool_id, **kwargs):
        """
        Update a DID Pool by ID.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_didpools_didpool_id(did_pool_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str did_pool_id: DID pool ID (required)
        :param DIDPool body: 
        :return: DIDPool
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['did_pool_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_didpools_didpool_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'did_pool_id' is set
        if ('did_pool_id' not in params) or (params['did_pool_id'] is None):
            raise ValueError("Missing the required parameter `did_pool_id` when calling `put_providers_edges_didpools_didpool_id`")

        resource_path = '/api/v2/telephony/providers/edges/didpools/{didPoolId}'.replace('{format}', 'json')
        path_params = {}
        if 'did_pool_id' in params:
            path_params['didPoolId'] = params['did_pool_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DIDPool',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_dids_did_id(self, did_id, **kwargs):
        """
        Update a DID by ID.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_dids_did_id(did_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str did_id: DID ID (required)
        :param DID body: 
        :return: DID
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['did_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_dids_did_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'did_id' is set
        if ('did_id' not in params) or (params['did_id'] is None):
            raise ValueError("Missing the required parameter `did_id` when calling `put_providers_edges_dids_did_id`")

        resource_path = '/api/v2/telephony/providers/edges/dids/{didId}'.replace('{format}', 'json')
        path_params = {}
        if 'did_id' in params:
            path_params['didId'] = params['did_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DID',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_edge_id(self, edge_id, **kwargs):
        """
        Update a edge.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_edge_id(edge_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :param Edge body: Edge
        :return: Edge
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_edge_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `put_providers_edges_edge_id`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Edge',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_edge_id_lines_line_id(self, edge_id, line_id, **kwargs):
        """
        Update a line.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_edge_id_lines_line_id(edge_id, line_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :param str line_id: Line ID (required)
        :param EdgeLine body: Line
        :return: EdgeLine
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id', 'line_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_edge_id_lines_line_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `put_providers_edges_edge_id_lines_line_id`")
        # verify the required parameter 'line_id' is set
        if ('line_id' not in params) or (params['line_id'] is None):
            raise ValueError("Missing the required parameter `line_id` when calling `put_providers_edges_edge_id_lines_line_id`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/lines/{lineId}'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']
        if 'line_id' in params:
            path_params['lineId'] = params['line_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='EdgeLine',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_edge_id_logicalinterfaces_interface_id(self, edge_id, interface_id, **kwargs):
        """
        Update an edge logical interface.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_edge_id_logicalinterfaces_interface_id(edge_id, interface_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_id: Edge ID (required)
        :param str interface_id: Interface ID (required)
        :param DomainLogicalInterface body: 
        :return: DomainLogicalInterface
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_id', 'interface_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_edge_id_logicalinterfaces_interface_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_id' is set
        if ('edge_id' not in params) or (params['edge_id'] is None):
            raise ValueError("Missing the required parameter `edge_id` when calling `put_providers_edges_edge_id_logicalinterfaces_interface_id`")
        # verify the required parameter 'interface_id' is set
        if ('interface_id' not in params) or (params['interface_id'] is None):
            raise ValueError("Missing the required parameter `interface_id` when calling `put_providers_edges_edge_id_logicalinterfaces_interface_id`")

        resource_path = '/api/v2/telephony/providers/edges/{edgeId}/logicalinterfaces/{interfaceId}'.replace('{format}', 'json')
        path_params = {}
        if 'edge_id' in params:
            path_params['edgeId'] = params['edge_id']
        if 'interface_id' in params:
            path_params['interfaceId'] = params['interface_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='DomainLogicalInterface',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_edgegroups_edgegroup_id(self, edge_group_id, **kwargs):
        """
        Update an edge group.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_edgegroups_edgegroup_id(edge_group_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str edge_group_id: Edge group ID (required)
        :param EdgeGroup body: EdgeGroup
        :return: EdgeGroup
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['edge_group_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_edgegroups_edgegroup_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'edge_group_id' is set
        if ('edge_group_id' not in params) or (params['edge_group_id'] is None):
            raise ValueError("Missing the required parameter `edge_group_id` when calling `put_providers_edges_edgegroups_edgegroup_id`")

        resource_path = '/api/v2/telephony/providers/edges/edgegroups/{edgeGroupId}'.replace('{format}', 'json')
        path_params = {}
        if 'edge_group_id' in params:
            path_params['edgeGroupId'] = params['edge_group_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='EdgeGroup',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_endpoints_endpoint_id(self, endpoint_id, **kwargs):
        """
        Update endpoint
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_endpoints_endpoint_id(endpoint_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str endpoint_id: Endpoint ID (required)
        :param Endpoint body: EndpointTemplate
        :return: Endpoint
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['endpoint_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_endpoints_endpoint_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'endpoint_id' is set
        if ('endpoint_id' not in params) or (params['endpoint_id'] is None):
            raise ValueError("Missing the required parameter `endpoint_id` when calling `put_providers_edges_endpoints_endpoint_id`")

        resource_path = '/api/v2/telephony/providers/edges/endpoints/{endpointId}'.replace('{format}', 'json')
        path_params = {}
        if 'endpoint_id' in params:
            path_params['endpointId'] = params['endpoint_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Endpoint',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_extensionpools_extensionpool_id(self, extension_pool_id, **kwargs):
        """
        Update an extension pool by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_extensionpools_extensionpool_id(extension_pool_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str extension_pool_id: Extension pool ID (required)
        :param ExtensionPool body: ExtensionPool
        :return: ExtensionPool
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['extension_pool_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_extensionpools_extensionpool_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'extension_pool_id' is set
        if ('extension_pool_id' not in params) or (params['extension_pool_id'] is None):
            raise ValueError("Missing the required parameter `extension_pool_id` when calling `put_providers_edges_extensionpools_extensionpool_id`")

        resource_path = '/api/v2/telephony/providers/edges/extensionpools/{extensionPoolId}'.replace('{format}', 'json')
        path_params = {}
        if 'extension_pool_id' in params:
            path_params['extensionPoolId'] = params['extension_pool_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='ExtensionPool',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_extensions_extension_id(self, extension_id, **kwargs):
        """
        Update an extension by ID.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_extensions_extension_id(extension_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str extension_id: Extension ID (required)
        :param Extension body: 
        :return: Extension
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['extension_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_extensions_extension_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'extension_id' is set
        if ('extension_id' not in params) or (params['extension_id'] is None):
            raise ValueError("Missing the required parameter `extension_id` when calling `put_providers_edges_extensions_extension_id`")

        resource_path = '/api/v2/telephony/providers/edges/extensions/{extensionId}'.replace('{format}', 'json')
        path_params = {}
        if 'extension_id' in params:
            path_params['extensionId'] = params['extension_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Extension',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_outboundroutes_outboundroute_id(self, outbound_route_id, **kwargs):
        """
        Update outbound route
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_outboundroutes_outboundroute_id(outbound_route_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str outbound_route_id: Outbound route ID (required)
        :param OutboundRoute body: OutboundRoute
        :return: OutboundRoute
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['outbound_route_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_outboundroutes_outboundroute_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'outbound_route_id' is set
        if ('outbound_route_id' not in params) or (params['outbound_route_id'] is None):
            raise ValueError("Missing the required parameter `outbound_route_id` when calling `put_providers_edges_outboundroutes_outboundroute_id`")

        resource_path = '/api/v2/telephony/providers/edges/outboundroutes/{outboundRouteId}'.replace('{format}', 'json')
        path_params = {}
        if 'outbound_route_id' in params:
            path_params['outboundRouteId'] = params['outbound_route_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='OutboundRoute',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_phonebasesettings_phonebase_id(self, phone_base_id, **kwargs):
        """
        Update a Phone Base Settings by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_phonebasesettings_phonebase_id(phone_base_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str phone_base_id: Phone base ID (required)
        :param PhoneBase body: 
        :return: PhoneBase
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['phone_base_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_phonebasesettings_phonebase_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'phone_base_id' is set
        if ('phone_base_id' not in params) or (params['phone_base_id'] is None):
            raise ValueError("Missing the required parameter `phone_base_id` when calling `put_providers_edges_phonebasesettings_phonebase_id`")

        resource_path = '/api/v2/telephony/providers/edges/phonebasesettings/{phoneBaseId}'.replace('{format}', 'json')
        path_params = {}
        if 'phone_base_id' in params:
            path_params['phoneBaseId'] = params['phone_base_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='PhoneBase',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_phones_phone_id(self, phone_id, **kwargs):
        """
        Update a Phone by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_phones_phone_id(phone_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str phone_id: Phone ID (required)
        :param Phone body: 
        :return: Phone
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['phone_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_phones_phone_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'phone_id' is set
        if ('phone_id' not in params) or (params['phone_id'] is None):
            raise ValueError("Missing the required parameter `phone_id` when calling `put_providers_edges_phones_phone_id`")

        resource_path = '/api/v2/telephony/providers/edges/phones/{phoneId}'.replace('{format}', 'json')
        path_params = {}
        if 'phone_id' in params:
            path_params['phoneId'] = params['phone_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Phone',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_sites_site_id(self, site_id, **kwargs):
        """
        Update a endpoint.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_sites_site_id(site_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str site_id: Site ID (required)
        :param Site body: Site
        :return: Site
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['site_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_sites_site_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'site_id' is set
        if ('site_id' not in params) or (params['site_id'] is None):
            raise ValueError("Missing the required parameter `site_id` when calling `put_providers_edges_sites_site_id`")

        resource_path = '/api/v2/telephony/providers/edges/sites/{siteId}'.replace('{format}', 'json')
        path_params = {}
        if 'site_id' in params:
            path_params['siteId'] = params['site_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Site',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_sites_site_id_numberplans(self, site_id, **kwargs):
        """
        Update the list of Number Plans.
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_sites_site_id_numberplans(site_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str site_id: Site ID (required)
        :param list[NumberPlan] body: 
        :return: list[NumberPlan]
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['site_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_sites_site_id_numberplans" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'site_id' is set
        if ('site_id' not in params) or (params['site_id'] is None):
            raise ValueError("Missing the required parameter `site_id` when calling `put_providers_edges_sites_site_id_numberplans`")

        resource_path = '/api/v2/telephony/providers/edges/sites/{siteId}/numberplans'.replace('{format}', 'json')
        path_params = {}
        if 'site_id' in params:
            path_params['siteId'] = params['site_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='list[NumberPlan]',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def put_providers_edges_trunkbasesettings_trunkbasesettings_id(self, trunk_base_settings_id, **kwargs):
        """
        Update a Trunk Base Settings object by ID
        

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.put_providers_edges_trunkbasesettings_trunkbasesettings_id(trunk_base_settings_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str trunk_base_settings_id: Trunk Base ID (required)
        :param TrunkBase body: 
        :return: TrunkBase
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['trunk_base_settings_id', 'body']
        all_params.append('callback')

        params = locals()
        for key, val in iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method put_providers_edges_trunkbasesettings_trunkbasesettings_id" % key
                )
            params[key] = val
        del params['kwargs']

        # verify the required parameter 'trunk_base_settings_id' is set
        if ('trunk_base_settings_id' not in params) or (params['trunk_base_settings_id'] is None):
            raise ValueError("Missing the required parameter `trunk_base_settings_id` when calling `put_providers_edges_trunkbasesettings_trunkbasesettings_id`")

        resource_path = '/api/v2/telephony/providers/edges/trunkbasesettings/{trunkBaseSettingsId}'.replace('{format}', 'json')
        path_params = {}
        if 'trunk_base_settings_id' in params:
            path_params['trunkBaseSettingsId'] = params['trunk_base_settings_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in params:
            body_params = params['body']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['PureCloud Auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='TrunkBase',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response
