# coding: utf-8

"""
    Zadara VPSA Object Storage REST API

    # Overview  This document outlines the methods available for administrating your VPSA&#174; Object Storage. The API supports form-encoded, JSON, and XML requests, and can return either JSON or XML responses.  ## Usage  The majority of the APIs available require authentication which requires an API token to use. You can retrieve this token through the Users section of your VPSA, or through the API using the \"Return a user's access key\" API in the Users Section below.  ## Authentication Methods  The authentication token can be passed either through the access_key parameter inside of the body of the REST API request, or through the X-Access-Key header. Alternately, you can use the username and password parameters for authentication, but we do not recommend this method for anything other than possibly retrieving an API key.  By default , all operations are allowed only to VPSA Object Storage admin. Some actions are allowed by an account admin and they will be marked on the action's header  ## Timeouts  By default, all operations that don't complete within five seconds will return a message informing you that the action may take some time to complete. When using the API, this can cause some actions, such as adding drives to storage policy, to be undesirably asynchronous. You can specify your own timeout with the timeout parameter, in seconds, and a timeout value of -1 specifies an infinite timeout.  ## Metering API  Metering information can be retrieved using the VPSA Object Storage API for the following components:  - Accounts - Users - Drives - Virtual Controllers - Load Balancer Groups - Storage Policies  Metering information returned by the API is subject to the following constraints:  - 10 seconds interval - 1 hour range - 1 minute interval - 1 day range - 1 hour interval - 30 days range  Values outside the accepted range will be returned as 0.  ## Questions  If you have any questions or need support involving the REST API, please contact for assistance.   # noqa: E501

    OpenAPI spec version: 23.03-sp1
    Contact: support@zadarastorage.com
    Generated by: https://github.com/swagger-api/swagger-codegen.git
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from Zios.api_client import ApiClient


class SettingsApi(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):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

    def activate_encryption(self, **kwargs):  # noqa: E501
        """activate_encryption  # noqa: E501

        Activate Encryption.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.activate_encryption(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.activate_encryption_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.activate_encryption_with_http_info(**kwargs)  # noqa: E501
            return data

    def activate_encryption_with_http_info(self, **kwargs):  # noqa: E501
        """activate_encryption  # noqa: E501

        Activate Encryption.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.activate_encryption_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        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', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/activate_encryption.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def allow_tenant_name_in_object_stroage_url(self, allow_tenant_name_in_object_stroage_url, **kwargs):  # noqa: E501
        """allow_tenant_name_in_object_stroage_url  # noqa: E501

        Allow tenant name in object storage url.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.allow_tenant_name_in_object_stroage_url(allow_tenant_name_in_object_stroage_url, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param AllowTenantNameInObjectStroageUrl allow_tenant_name_in_object_stroage_url: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.allow_tenant_name_in_object_stroage_url_with_http_info(allow_tenant_name_in_object_stroage_url, **kwargs)  # noqa: E501
        else:
            (data) = self.allow_tenant_name_in_object_stroage_url_with_http_info(allow_tenant_name_in_object_stroage_url, **kwargs)  # noqa: E501
            return data

    def allow_tenant_name_in_object_stroage_url_with_http_info(self, allow_tenant_name_in_object_stroage_url, **kwargs):  # noqa: E501
        """allow_tenant_name_in_object_stroage_url  # noqa: E501

        Allow tenant name in object storage url.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.allow_tenant_name_in_object_stroage_url_with_http_info(allow_tenant_name_in_object_stroage_url, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param AllowTenantNameInObjectStroageUrl allow_tenant_name_in_object_stroage_url: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['allow_tenant_name_in_object_stroage_url']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method allow_tenant_name_in_object_stroage_url" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'allow_tenant_name_in_object_stroage_url' is set
        if self.api_client.client_side_validation and ('allow_tenant_name_in_object_stroage_url' not in params or
                                                       params['allow_tenant_name_in_object_stroage_url'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `allow_tenant_name_in_object_stroage_url` when calling `allow_tenant_name_in_object_stroage_url`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'allow_tenant_name_in_object_stroage_url' in params:
            body_params = params['allow_tenant_name_in_object_stroage_url']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/tenant_name_in_url.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def change_mtu_for_network_interface(self, change_mtu_for_network_interface, **kwargs):  # noqa: E501
        """change_mtu_for_network_interface  # noqa: E501

        Changes the MTU for a network interface.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.change_mtu_for_network_interface(change_mtu_for_network_interface, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ChangeMtuForNetworkInterface change_mtu_for_network_interface: (required)
        :return: InlineResponse20031
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.change_mtu_for_network_interface_with_http_info(change_mtu_for_network_interface, **kwargs)  # noqa: E501
        else:
            (data) = self.change_mtu_for_network_interface_with_http_info(change_mtu_for_network_interface, **kwargs)  # noqa: E501
            return data

    def change_mtu_for_network_interface_with_http_info(self, change_mtu_for_network_interface, **kwargs):  # noqa: E501
        """change_mtu_for_network_interface  # noqa: E501

        Changes the MTU for a network interface.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.change_mtu_for_network_interface_with_http_info(change_mtu_for_network_interface, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ChangeMtuForNetworkInterface change_mtu_for_network_interface: (required)
        :return: InlineResponse20031
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['change_mtu_for_network_interface']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method change_mtu_for_network_interface" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'change_mtu_for_network_interface' is set
        if self.api_client.client_side_validation and ('change_mtu_for_network_interface' not in params or
                                                       params['change_mtu_for_network_interface'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `change_mtu_for_network_interface` when calling `change_mtu_for_network_interface`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'change_mtu_for_network_interface' in params:
            body_params = params['change_mtu_for_network_interface']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/settings/set_mtu.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20031',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def change_region(self, change_region, **kwargs):  # noqa: E501
        """change_region  # noqa: E501

        Change Region.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.change_region(change_region, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ChangeRegion change_region: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.change_region_with_http_info(change_region, **kwargs)  # noqa: E501
        else:
            (data) = self.change_region_with_http_info(change_region, **kwargs)  # noqa: E501
            return data

    def change_region_with_http_info(self, change_region, **kwargs):  # noqa: E501
        """change_region  # noqa: E501

        Change Region.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.change_region_with_http_info(change_region, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param ChangeRegion change_region: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['change_region']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method change_region" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'change_region' is set
        if self.api_client.client_side_validation and ('change_region' not in params or
                                                       params['change_region'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `change_region` when calling `change_region`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'change_region' in params:
            body_params = params['change_region']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/change_region.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def define_custom_dns_servers(self, define_custom_dns_servers, **kwargs):  # noqa: E501
        """define_custom_dns_servers  # noqa: E501

        Defines custom DNS servers.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.define_custom_dns_servers(define_custom_dns_servers, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DefineCustomDnsServers define_custom_dns_servers: (required)
        :return: InlineResponse20032
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.define_custom_dns_servers_with_http_info(define_custom_dns_servers, **kwargs)  # noqa: E501
        else:
            (data) = self.define_custom_dns_servers_with_http_info(define_custom_dns_servers, **kwargs)  # noqa: E501
            return data

    def define_custom_dns_servers_with_http_info(self, define_custom_dns_servers, **kwargs):  # noqa: E501
        """define_custom_dns_servers  # noqa: E501

        Defines custom DNS servers.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.define_custom_dns_servers_with_http_info(define_custom_dns_servers, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DefineCustomDnsServers define_custom_dns_servers: (required)
        :return: InlineResponse20032
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['define_custom_dns_servers']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method define_custom_dns_servers" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'define_custom_dns_servers' is set
        if self.api_client.client_side_validation and ('define_custom_dns_servers' not in params or
                                                       params['define_custom_dns_servers'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `define_custom_dns_servers` when calling `define_custom_dns_servers`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'define_custom_dns_servers' in params:
            body_params = params['define_custom_dns_servers']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/custom_dns_servers.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20032',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def disable_encryption(self, **kwargs):  # noqa: E501
        """disable_encryption  # noqa: E501

        Disable Encryption.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_encryption(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.disable_encryption_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.disable_encryption_with_http_info(**kwargs)  # noqa: E501
            return data

    def disable_encryption_with_http_info(self, **kwargs):  # noqa: E501
        """disable_encryption  # noqa: E501

        Disable Encryption.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_encryption_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        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', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/disable_encryption.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_network(self, **kwargs):  # noqa: E501
        """get_network  # noqa: E501

        Returns network settings.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_network(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: InlineResponse20028
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_network_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.get_network_with_http_info(**kwargs)  # noqa: E501
            return data

    def get_network_with_http_info(self, **kwargs):  # noqa: E501
        """get_network  # noqa: E501

        Returns network settings.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_network_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: InlineResponse20028
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        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', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/settings/network.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20028',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_settings_config(self, **kwargs):  # noqa: E501
        """get_settings_config  # noqa: E501

        Returns settings.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_settings_config(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: InlineResponse20027
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_settings_config_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.get_settings_config_with_http_info(**kwargs)  # noqa: E501
            return data

    def get_settings_config_with_http_info(self, **kwargs):  # noqa: E501
        """get_settings_config  # noqa: E501

        Returns settings.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_settings_config_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: InlineResponse20027
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        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', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/settings_config.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20027',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_ssl_cert_info(self, **kwargs):  # noqa: E501
        """get_ssl_cert_info  # noqa: E501

        Get SSL certificate details.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_ssl_cert_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: InlineResponse20030
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_ssl_cert_info_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.get_ssl_cert_info_with_http_info(**kwargs)  # noqa: E501
            return data

    def get_ssl_cert_info_with_http_info(self, **kwargs):  # noqa: E501
        """get_ssl_cert_info  # noqa: E501

        Get SSL certificate details.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_ssl_cert_info_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: InlineResponse20030
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        collection_formats = {}

        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', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/get_ssl_cert_info.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20030',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def restore_encryption(self, restore_encryption, **kwargs):  # noqa: E501
        """restore_encryption  # noqa: E501

        Restore Encryption password.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_encryption(restore_encryption, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param RestoreEncryption restore_encryption: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.restore_encryption_with_http_info(restore_encryption, **kwargs)  # noqa: E501
        else:
            (data) = self.restore_encryption_with_http_info(restore_encryption, **kwargs)  # noqa: E501
            return data

    def restore_encryption_with_http_info(self, restore_encryption, **kwargs):  # noqa: E501
        """restore_encryption  # noqa: E501

        Restore Encryption password.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_encryption_with_http_info(restore_encryption, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param RestoreEncryption restore_encryption: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['restore_encryption']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method restore_encryption" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'restore_encryption' is set
        if self.api_client.client_side_validation and ('restore_encryption' not in params or
                                                       params['restore_encryption'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `restore_encryption` when calling `restore_encryption`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'restore_encryption' in params:
            body_params = params['restore_encryption']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/restore_encryption.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_api_errors_alerts(self, set_api_errors_alerts, **kwargs):  # noqa: E501
        """set_api_errors_alerts  # noqa: E501

        Set API errors alerts.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_api_errors_alerts(set_api_errors_alerts, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetApiErrorsAlerts set_api_errors_alerts: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_api_errors_alerts_with_http_info(set_api_errors_alerts, **kwargs)  # noqa: E501
        else:
            (data) = self.set_api_errors_alerts_with_http_info(set_api_errors_alerts, **kwargs)  # noqa: E501
            return data

    def set_api_errors_alerts_with_http_info(self, set_api_errors_alerts, **kwargs):  # noqa: E501
        """set_api_errors_alerts  # noqa: E501

        Set API errors alerts.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_api_errors_alerts_with_http_info(set_api_errors_alerts, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetApiErrorsAlerts set_api_errors_alerts: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['set_api_errors_alerts']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_api_errors_alerts" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'set_api_errors_alerts' is set
        if self.api_client.client_side_validation and ('set_api_errors_alerts' not in params or
                                                       params['set_api_errors_alerts'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `set_api_errors_alerts` when calling `set_api_errors_alerts`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'set_api_errors_alerts' in params:
            body_params = params['set_api_errors_alerts']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/api_errors.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_api_hostname(self, set_api_hostname, **kwargs):  # noqa: E501
        """set_api_hostname  # noqa: E501

        Set API Hostname.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_api_hostname(set_api_hostname, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetApiHostname set_api_hostname: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_api_hostname_with_http_info(set_api_hostname, **kwargs)  # noqa: E501
        else:
            (data) = self.set_api_hostname_with_http_info(set_api_hostname, **kwargs)  # noqa: E501
            return data

    def set_api_hostname_with_http_info(self, set_api_hostname, **kwargs):  # noqa: E501
        """set_api_hostname  # noqa: E501

        Set API Hostname.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_api_hostname_with_http_info(set_api_hostname, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetApiHostname set_api_hostname: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['set_api_hostname']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_api_hostname" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'set_api_hostname' is set
        if self.api_client.client_side_validation and ('set_api_hostname' not in params or
                                                       params['set_api_hostname'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `set_api_hostname` when calling `set_api_hostname`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'set_api_hostname' in params:
            body_params = params['set_api_hostname']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/api_hostname.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_api_ip(self, set_api_ip, **kwargs):  # noqa: E501
        """set_api_ip  # noqa: E501

        Set API IP.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_api_ip(set_api_ip, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetApiIp set_api_ip: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_api_ip_with_http_info(set_api_ip, **kwargs)  # noqa: E501
        else:
            (data) = self.set_api_ip_with_http_info(set_api_ip, **kwargs)  # noqa: E501
            return data

    def set_api_ip_with_http_info(self, set_api_ip, **kwargs):  # noqa: E501
        """set_api_ip  # noqa: E501

        Set API IP.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_api_ip_with_http_info(set_api_ip, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetApiIp set_api_ip: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['set_api_ip']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_api_ip" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'set_api_ip' is set
        if self.api_client.client_side_validation and ('set_api_ip' not in params or
                                                       params['set_api_ip'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `set_api_ip` when calling `set_api_ip`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'set_api_ip' in params:
            body_params = params['set_api_ip']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/api_ip.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_billing_currency(self, set_billing_currency, **kwargs):  # noqa: E501
        """set_billing_currency  # noqa: E501

        Set billing currency.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_billing_currency(set_billing_currency, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetBillingCurrency set_billing_currency: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_billing_currency_with_http_info(set_billing_currency, **kwargs)  # noqa: E501
        else:
            (data) = self.set_billing_currency_with_http_info(set_billing_currency, **kwargs)  # noqa: E501
            return data

    def set_billing_currency_with_http_info(self, set_billing_currency, **kwargs):  # noqa: E501
        """set_billing_currency  # noqa: E501

        Set billing currency.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_billing_currency_with_http_info(set_billing_currency, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetBillingCurrency set_billing_currency: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['set_billing_currency']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_billing_currency" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'set_billing_currency' is set
        if self.api_client.client_side_validation and ('set_billing_currency' not in params or
                                                       params['set_billing_currency'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `set_billing_currency` when calling `set_billing_currency`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'set_billing_currency' in params:
            body_params = params['set_billing_currency']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/billing_currency.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_containers_virtual_hosted_style_support(self, set_containers_virtual_hosted_style_support, **kwargs):  # noqa: E501
        """set_containers_virtual_hosted_style_support  # noqa: E501

        Set containers Virtual-hosted style support.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_containers_virtual_hosted_style_support(set_containers_virtual_hosted_style_support, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetContainersVirtualHostedStyleSupport set_containers_virtual_hosted_style_support: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_containers_virtual_hosted_style_support_with_http_info(set_containers_virtual_hosted_style_support, **kwargs)  # noqa: E501
        else:
            (data) = self.set_containers_virtual_hosted_style_support_with_http_info(set_containers_virtual_hosted_style_support, **kwargs)  # noqa: E501
            return data

    def set_containers_virtual_hosted_style_support_with_http_info(self, set_containers_virtual_hosted_style_support, **kwargs):  # noqa: E501
        """set_containers_virtual_hosted_style_support  # noqa: E501

        Set containers Virtual-hosted style support.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_containers_virtual_hosted_style_support_with_http_info(set_containers_virtual_hosted_style_support, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetContainersVirtualHostedStyleSupport set_containers_virtual_hosted_style_support: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['set_containers_virtual_hosted_style_support']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_containers_virtual_hosted_style_support" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'set_containers_virtual_hosted_style_support' is set
        if self.api_client.client_side_validation and ('set_containers_virtual_hosted_style_support' not in params or
                                                       params['set_containers_virtual_hosted_style_support'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `set_containers_virtual_hosted_style_support` when calling `set_containers_virtual_hosted_style_support`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'set_containers_virtual_hosted_style_support' in params:
            body_params = params['set_containers_virtual_hosted_style_support']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/vhs_state.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_data_transfer_pricing(self, set_data_transfer_pricing, **kwargs):  # noqa: E501
        """set_data_transfer_pricing  # noqa: E501

        Set data transfer pricing.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_data_transfer_pricing(set_data_transfer_pricing, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetDataTransferPricing set_data_transfer_pricing: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_data_transfer_pricing_with_http_info(set_data_transfer_pricing, **kwargs)  # noqa: E501
        else:
            (data) = self.set_data_transfer_pricing_with_http_info(set_data_transfer_pricing, **kwargs)  # noqa: E501
            return data

    def set_data_transfer_pricing_with_http_info(self, set_data_transfer_pricing, **kwargs):  # noqa: E501
        """set_data_transfer_pricing  # noqa: E501

        Set data transfer pricing.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_data_transfer_pricing_with_http_info(set_data_transfer_pricing, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetDataTransferPricing set_data_transfer_pricing: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['set_data_transfer_pricing']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_data_transfer_pricing" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'set_data_transfer_pricing' is set
        if self.api_client.client_side_validation and ('set_data_transfer_pricing' not in params or
                                                       params['set_data_transfer_pricing'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `set_data_transfer_pricing` when calling `set_data_transfer_pricing`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'set_data_transfer_pricing' in params:
            body_params = params['set_data_transfer_pricing']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/data_transfer_pricing.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_encryption(self, set_encryption, **kwargs):  # noqa: E501
        """set_encryption  # noqa: E501

        Set Encryption.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_encryption(set_encryption, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetEncryption set_encryption: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_encryption_with_http_info(set_encryption, **kwargs)  # noqa: E501
        else:
            (data) = self.set_encryption_with_http_info(set_encryption, **kwargs)  # noqa: E501
            return data

    def set_encryption_with_http_info(self, set_encryption, **kwargs):  # noqa: E501
        """set_encryption  # noqa: E501

        Set Encryption.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_encryption_with_http_info(set_encryption, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetEncryption set_encryption: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['set_encryption']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_encryption" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'set_encryption' is set
        if self.api_client.client_side_validation and ('set_encryption' not in params or
                                                       params['set_encryption'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `set_encryption` when calling `set_encryption`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'set_encryption' in params:
            body_params = params['set_encryption']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/encryption.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_global_rate_limit(self, set_global_rate_limit, **kwargs):  # noqa: E501
        """set_global_rate_limit  # noqa: E501

        Set global rate limit.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_global_rate_limit(set_global_rate_limit, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetGlobalRateLimit set_global_rate_limit: (required)
        :return: InlineResponse20033
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_global_rate_limit_with_http_info(set_global_rate_limit, **kwargs)  # noqa: E501
        else:
            (data) = self.set_global_rate_limit_with_http_info(set_global_rate_limit, **kwargs)  # noqa: E501
            return data

    def set_global_rate_limit_with_http_info(self, set_global_rate_limit, **kwargs):  # noqa: E501
        """set_global_rate_limit  # noqa: E501

        Set global rate limit.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_global_rate_limit_with_http_info(set_global_rate_limit, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetGlobalRateLimit set_global_rate_limit: (required)
        :return: InlineResponse20033
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['set_global_rate_limit']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_global_rate_limit" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'set_global_rate_limit' is set
        if self.api_client.client_side_validation and ('set_global_rate_limit' not in params or
                                                       params['set_global_rate_limit'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `set_global_rate_limit` when calling `set_global_rate_limit`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'set_global_rate_limit' in params:
            body_params = params['set_global_rate_limit']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/global_rate_limit.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20033',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_gradual_policy_expansion_percentage(self, set_gradual_policy_expansion_percentage, **kwargs):  # noqa: E501
        """set_gradual_policy_expansion_percentage  # noqa: E501

        Gradual Disk Add - Percentage of drives to be added in each step  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_gradual_policy_expansion_percentage(set_gradual_policy_expansion_percentage, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetGradualPolicyExpansionPercentage set_gradual_policy_expansion_percentage: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_gradual_policy_expansion_percentage_with_http_info(set_gradual_policy_expansion_percentage, **kwargs)  # noqa: E501
        else:
            (data) = self.set_gradual_policy_expansion_percentage_with_http_info(set_gradual_policy_expansion_percentage, **kwargs)  # noqa: E501
            return data

    def set_gradual_policy_expansion_percentage_with_http_info(self, set_gradual_policy_expansion_percentage, **kwargs):  # noqa: E501
        """set_gradual_policy_expansion_percentage  # noqa: E501

        Gradual Disk Add - Percentage of drives to be added in each step  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_gradual_policy_expansion_percentage_with_http_info(set_gradual_policy_expansion_percentage, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetGradualPolicyExpansionPercentage set_gradual_policy_expansion_percentage: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['set_gradual_policy_expansion_percentage']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_gradual_policy_expansion_percentage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'set_gradual_policy_expansion_percentage' is set
        if self.api_client.client_side_validation and ('set_gradual_policy_expansion_percentage' not in params or
                                                       params['set_gradual_policy_expansion_percentage'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `set_gradual_policy_expansion_percentage` when calling `set_gradual_policy_expansion_percentage`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'set_gradual_policy_expansion_percentage' in params:
            body_params = params['set_gradual_policy_expansion_percentage']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/set_gradual_policy_expansion_percentage.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_lb_mode(self, set_lb_mode, **kwargs):  # noqa: E501
        """set_lb_mode  # noqa: E501

        Load balancer mode - Direct Server Return (Default) / NAT  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_lb_mode(set_lb_mode, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetLbMode set_lb_mode: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_lb_mode_with_http_info(set_lb_mode, **kwargs)  # noqa: E501
        else:
            (data) = self.set_lb_mode_with_http_info(set_lb_mode, **kwargs)  # noqa: E501
            return data

    def set_lb_mode_with_http_info(self, set_lb_mode, **kwargs):  # noqa: E501
        """set_lb_mode  # noqa: E501

        Load balancer mode - Direct Server Return (Default) / NAT  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_lb_mode_with_http_info(set_lb_mode, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetLbMode set_lb_mode: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['set_lb_mode']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_lb_mode" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'set_lb_mode' is set
        if self.api_client.client_side_validation and ('set_lb_mode' not in params or
                                                       params['set_lb_mode'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `set_lb_mode` when calling `set_lb_mode`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'set_lb_mode' in params:
            body_params = params['set_lb_mode']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/load_balancer_mode.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def set_public_ip_hostname(self, set_public_ip_hostname, **kwargs):  # noqa: E501
        """set_public_ip_hostname  # noqa: E501

        Set Public API Hostname.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_public_ip_hostname(set_public_ip_hostname, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetPublicIpHostname set_public_ip_hostname: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.set_public_ip_hostname_with_http_info(set_public_ip_hostname, **kwargs)  # noqa: E501
        else:
            (data) = self.set_public_ip_hostname_with_http_info(set_public_ip_hostname, **kwargs)  # noqa: E501
            return data

    def set_public_ip_hostname_with_http_info(self, set_public_ip_hostname, **kwargs):  # noqa: E501
        """set_public_ip_hostname  # noqa: E501

        Set Public API Hostname.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_public_ip_hostname_with_http_info(set_public_ip_hostname, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SetPublicIpHostname set_public_ip_hostname: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['set_public_ip_hostname']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_public_ip_hostname" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'set_public_ip_hostname' is set
        if self.api_client.client_side_validation and ('set_public_ip_hostname' not in params or
                                                       params['set_public_ip_hostname'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `set_public_ip_hostname` when calling `set_public_ip_hostname`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'set_public_ip_hostname' in params:
            body_params = params['set_public_ip_hostname']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/public_api_hostname.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def ssl_termination(self, ssl_termination, **kwargs):  # noqa: E501
        """ssl_termination  # noqa: E501

        Set SSL Termination for VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.ssl_termination(ssl_termination, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SslTermination ssl_termination: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.ssl_termination_with_http_info(ssl_termination, **kwargs)  # noqa: E501
        else:
            (data) = self.ssl_termination_with_http_info(ssl_termination, **kwargs)  # noqa: E501
            return data

    def ssl_termination_with_http_info(self, ssl_termination, **kwargs):  # noqa: E501
        """ssl_termination  # noqa: E501

        Set SSL Termination for VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.ssl_termination_with_http_info(ssl_termination, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SslTermination ssl_termination: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['ssl_termination']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method ssl_termination" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'ssl_termination' is set
        if self.api_client.client_side_validation and ('ssl_termination' not in params or
                                                       params['ssl_termination'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `ssl_termination` when calling `ssl_termination`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'ssl_termination' in params:
            body_params = params['ssl_termination']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/ssl_termination.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def token_expiration(self, token_expiration, **kwargs):  # noqa: E501
        """token_expiration  # noqa: E501

        Token expiration (in minutes)  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.token_expiration(token_expiration, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TokenExpiration token_expiration: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.token_expiration_with_http_info(token_expiration, **kwargs)  # noqa: E501
        else:
            (data) = self.token_expiration_with_http_info(token_expiration, **kwargs)  # noqa: E501
            return data

    def token_expiration_with_http_info(self, token_expiration, **kwargs):  # noqa: E501
        """token_expiration  # noqa: E501

        Token expiration (in minutes)  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.token_expiration_with_http_info(token_expiration, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param TokenExpiration token_expiration: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['token_expiration']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method token_expiration" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'token_expiration' is set
        if self.api_client.client_side_validation and ('token_expiration' not in params or
                                                       params['token_expiration'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `token_expiration` when calling `token_expiration`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'token_expiration' in params:
            body_params = params['token_expiration']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/token_expiry.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def upload_ssl_pem(self, upload_ssl_pem, **kwargs):  # noqa: E501
        """upload_ssl_pem  # noqa: E501

        Upload ssl pem.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upload_ssl_pem(upload_ssl_pem, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param UploadSslPem upload_ssl_pem: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.upload_ssl_pem_with_http_info(upload_ssl_pem, **kwargs)  # noqa: E501
        else:
            (data) = self.upload_ssl_pem_with_http_info(upload_ssl_pem, **kwargs)  # noqa: E501
            return data

    def upload_ssl_pem_with_http_info(self, upload_ssl_pem, **kwargs):  # noqa: E501
        """upload_ssl_pem  # noqa: E501

        Upload ssl pem.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upload_ssl_pem_with_http_info(upload_ssl_pem, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param UploadSslPem upload_ssl_pem: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['upload_ssl_pem']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method upload_ssl_pem" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'upload_ssl_pem' is set
        if self.api_client.client_side_validation and ('upload_ssl_pem' not in params or
                                                       params['upload_ssl_pem'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `upload_ssl_pem` when calling `upload_ssl_pem`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'upload_ssl_pem' in params:
            body_params = params['upload_ssl_pem']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['api_key']  # noqa: E501

        return self.api_client.call_api(
            '/zios/settings/set_ssl_pem.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20029',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)
