# coding: utf-8

"""
    Zadara Provisioning Portal API

     # Overview  This document outlines the methods available for creation and high-level administration of Zadara Storage VPSAs via a Zadara Storage Provisioning Portal. This API supports form-encoded requests, and can return either JSON or XML responses.  ## Endpoint  The base URL for the requests is the Provisioning Portal URL you created your VPSA through - for example: https://manage.zadarastorage.com/, and all APIs will be prefixed with /api as noted in the documentation below.  ## Authentication  To use this API, an authentication token is required. The API for retrieving this token can be found below in the Authentication section. You may pass this token in requests either via the the X-Token header or via basic authentication (base64 encoded) in Authorization header.  ## 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 ProvisioningPortal.api_client import ApiClient


class VPSAApi(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 add_proxy_vc_to_vpsa_object_storage(self, vpsa_id, add_proxy_vc_to_vpsa_object_storage, **kwargs):  # noqa: E501
        """add_proxy_vc_to_vpsa_object_storage  # noqa: E501

        Add a proxy Virtual Controller to a 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.add_proxy_vc_to_vpsa_object_storage(vpsa_id, add_proxy_vc_to_vpsa_object_storage, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param AddProxyVcToVpsaObjectStorage add_proxy_vc_to_vpsa_object_storage: (required)
        :return: InlineResponse20035
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.add_proxy_vc_to_vpsa_object_storage_with_http_info(vpsa_id, add_proxy_vc_to_vpsa_object_storage, **kwargs)  # noqa: E501
        else:
            (data) = self.add_proxy_vc_to_vpsa_object_storage_with_http_info(vpsa_id, add_proxy_vc_to_vpsa_object_storage, **kwargs)  # noqa: E501
            return data

    def add_proxy_vc_to_vpsa_object_storage_with_http_info(self, vpsa_id, add_proxy_vc_to_vpsa_object_storage, **kwargs):  # noqa: E501
        """add_proxy_vc_to_vpsa_object_storage  # noqa: E501

        Add a proxy Virtual Controller to a 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.add_proxy_vc_to_vpsa_object_storage_with_http_info(vpsa_id, add_proxy_vc_to_vpsa_object_storage, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param AddProxyVcToVpsaObjectStorage add_proxy_vc_to_vpsa_object_storage: (required)
        :return: InlineResponse20035
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id', 'add_proxy_vc_to_vpsa_object_storage']  # 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 add_proxy_vc_to_vpsa_object_storage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `add_proxy_vc_to_vpsa_object_storage`")  # noqa: E501
        # verify the required parameter 'add_proxy_vc_to_vpsa_object_storage' is set
        if self.api_client.client_side_validation and ('add_proxy_vc_to_vpsa_object_storage' not in params or
                                                       params['add_proxy_vc_to_vpsa_object_storage'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `add_proxy_vc_to_vpsa_object_storage` when calling `add_proxy_vc_to_vpsa_object_storage`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `add_proxy_vc_to_vpsa_object_storage`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'add_proxy_vc_to_vpsa_object_storage' in params:
            body_params = params['add_proxy_vc_to_vpsa_object_storage']
        # 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(
            '/vpsas/{vpsa_id}/proxy_vcs/add.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20035',  # 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 add_storage_policy_to_vpsa_object_storage(self, vpsa_id, add_storage_policy_to_vpsa_object_storage, **kwargs):  # noqa: E501
        """add_storage_policy_to_vpsa_object_storage  # noqa: E501

        Add a storage policy to a 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.add_storage_policy_to_vpsa_object_storage(vpsa_id, add_storage_policy_to_vpsa_object_storage, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param AddStoragePolicyToVpsaObjectStorage add_storage_policy_to_vpsa_object_storage: (required)
        :return: Default
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.add_storage_policy_to_vpsa_object_storage_with_http_info(vpsa_id, add_storage_policy_to_vpsa_object_storage, **kwargs)  # noqa: E501
        else:
            (data) = self.add_storage_policy_to_vpsa_object_storage_with_http_info(vpsa_id, add_storage_policy_to_vpsa_object_storage, **kwargs)  # noqa: E501
            return data

    def add_storage_policy_to_vpsa_object_storage_with_http_info(self, vpsa_id, add_storage_policy_to_vpsa_object_storage, **kwargs):  # noqa: E501
        """add_storage_policy_to_vpsa_object_storage  # noqa: E501

        Add a storage policy to a 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.add_storage_policy_to_vpsa_object_storage_with_http_info(vpsa_id, add_storage_policy_to_vpsa_object_storage, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param AddStoragePolicyToVpsaObjectStorage add_storage_policy_to_vpsa_object_storage: (required)
        :return: Default
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id', 'add_storage_policy_to_vpsa_object_storage']  # 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 add_storage_policy_to_vpsa_object_storage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `add_storage_policy_to_vpsa_object_storage`")  # noqa: E501
        # verify the required parameter 'add_storage_policy_to_vpsa_object_storage' is set
        if self.api_client.client_side_validation and ('add_storage_policy_to_vpsa_object_storage' not in params or
                                                       params['add_storage_policy_to_vpsa_object_storage'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `add_storage_policy_to_vpsa_object_storage` when calling `add_storage_policy_to_vpsa_object_storage`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `add_storage_policy_to_vpsa_object_storage`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'add_storage_policy_to_vpsa_object_storage' in params:
            body_params = params['add_storage_policy_to_vpsa_object_storage']
        # 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(
            '/vpsas/{vpsa_id}/storage_policy.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Default',  # 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 add_storage_to_vpsa(self, vpsa_id, add_storage_to_vpsa, **kwargs):  # noqa: E501
        """add_storage_to_vpsa  # noqa: E501

        Add additional storage to a VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_storage_to_vpsa(vpsa_id, add_storage_to_vpsa, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param AddStorageToVpsa add_storage_to_vpsa: (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.add_storage_to_vpsa_with_http_info(vpsa_id, add_storage_to_vpsa, **kwargs)  # noqa: E501
        else:
            (data) = self.add_storage_to_vpsa_with_http_info(vpsa_id, add_storage_to_vpsa, **kwargs)  # noqa: E501
            return data

    def add_storage_to_vpsa_with_http_info(self, vpsa_id, add_storage_to_vpsa, **kwargs):  # noqa: E501
        """add_storage_to_vpsa  # noqa: E501

        Add additional storage to a VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_storage_to_vpsa_with_http_info(vpsa_id, add_storage_to_vpsa, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param AddStorageToVpsa add_storage_to_vpsa: (required)
        :return: InlineResponse20031
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id', 'add_storage_to_vpsa']  # 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 add_storage_to_vpsa" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `add_storage_to_vpsa`")  # noqa: E501
        # verify the required parameter 'add_storage_to_vpsa' is set
        if self.api_client.client_side_validation and ('add_storage_to_vpsa' not in params or
                                                       params['add_storage_to_vpsa'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `add_storage_to_vpsa` when calling `add_storage_to_vpsa`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `add_storage_to_vpsa`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'add_storage_to_vpsa' in params:
            body_params = params['add_storage_to_vpsa']
        # 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(
            '/vpsas/{vpsa_id}/drives.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 add_virtual_network_vpsa(self, vpsa_id, add_virtual_network_vpsa, **kwargs):  # noqa: E501
        """add_virtual_network_vpsa  # noqa: E501

        Add a Virtual Network Interface to a VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_virtual_network_vpsa(vpsa_id, add_virtual_network_vpsa, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param AddVirtualNetworkVpsa add_virtual_network_vpsa: (required)
        :return: InlineResponse20039
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.add_virtual_network_vpsa_with_http_info(vpsa_id, add_virtual_network_vpsa, **kwargs)  # noqa: E501
        else:
            (data) = self.add_virtual_network_vpsa_with_http_info(vpsa_id, add_virtual_network_vpsa, **kwargs)  # noqa: E501
            return data

    def add_virtual_network_vpsa_with_http_info(self, vpsa_id, add_virtual_network_vpsa, **kwargs):  # noqa: E501
        """add_virtual_network_vpsa  # noqa: E501

        Add a Virtual Network Interface to a VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_virtual_network_vpsa_with_http_info(vpsa_id, add_virtual_network_vpsa, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param AddVirtualNetworkVpsa add_virtual_network_vpsa: (required)
        :return: InlineResponse20039
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id', 'add_virtual_network_vpsa']  # 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 add_virtual_network_vpsa" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `add_virtual_network_vpsa`")  # noqa: E501
        # verify the required parameter 'add_virtual_network_vpsa' is set
        if self.api_client.client_side_validation and ('add_virtual_network_vpsa' not in params or
                                                       params['add_virtual_network_vpsa'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `add_virtual_network_vpsa` when calling `add_virtual_network_vpsa`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `add_virtual_network_vpsa`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'add_virtual_network_vpsa' in params:
            body_params = params['add_virtual_network_vpsa']
        # 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(
            '/vpsas/{vpsa_id}/add_vni.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20039',  # 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 assign_public_ip_vpsa(self, vpsa_id, **kwargs):  # noqa: E501
        """assign_public_ip_vpsa  # noqa: E501

        Assign a public IP to a VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.assign_public_ip_vpsa(vpsa_id, async_req=True)
        >>> result = thread.get()

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

    def assign_public_ip_vpsa_with_http_info(self, vpsa_id, **kwargs):  # noqa: E501
        """assign_public_ip_vpsa  # noqa: E501

        Assign a public IP to a VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.assign_public_ip_vpsa_with_http_info(vpsa_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :return: InlineResponse20036
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id']  # 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 assign_public_ip_vpsa" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `assign_public_ip_vpsa`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `assign_public_ip_vpsa`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        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(
            '/vpsas/{vpsa_id}/public_ip.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20036',  # 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_vpsa_flash_cache_capacity(self, vpsa_id, change_vpsa_flash_cache_capacity, **kwargs):  # noqa: E501
        """change_vpsa_flash_cache_capacity  # noqa: E501

        Change a VPSA's extended flash cache capacity.  # 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_vpsa_flash_cache_capacity(vpsa_id, change_vpsa_flash_cache_capacity, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param ChangeVpsaFlashCacheCapacity change_vpsa_flash_cache_capacity: (required)
        :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.change_vpsa_flash_cache_capacity_with_http_info(vpsa_id, change_vpsa_flash_cache_capacity, **kwargs)  # noqa: E501
        else:
            (data) = self.change_vpsa_flash_cache_capacity_with_http_info(vpsa_id, change_vpsa_flash_cache_capacity, **kwargs)  # noqa: E501
            return data

    def change_vpsa_flash_cache_capacity_with_http_info(self, vpsa_id, change_vpsa_flash_cache_capacity, **kwargs):  # noqa: E501
        """change_vpsa_flash_cache_capacity  # noqa: E501

        Change a VPSA's extended flash cache capacity.  # 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_vpsa_flash_cache_capacity_with_http_info(vpsa_id, change_vpsa_flash_cache_capacity, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param ChangeVpsaFlashCacheCapacity change_vpsa_flash_cache_capacity: (required)
        :return: InlineResponse20030
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id', 'change_vpsa_flash_cache_capacity']  # 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_vpsa_flash_cache_capacity" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `change_vpsa_flash_cache_capacity`")  # noqa: E501
        # verify the required parameter 'change_vpsa_flash_cache_capacity' is set
        if self.api_client.client_side_validation and ('change_vpsa_flash_cache_capacity' not in params or
                                                       params['change_vpsa_flash_cache_capacity'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `change_vpsa_flash_cache_capacity` when calling `change_vpsa_flash_cache_capacity`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `change_vpsa_flash_cache_capacity`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'change_vpsa_flash_cache_capacity' in params:
            body_params = params['change_vpsa_flash_cache_capacity']
        # 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(
            '/vpsas/{vpsa_id}/cache.json', 'POST',
            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 change_vpsa_zadara_engine(self, vpsa_id, change_vpsa_zadara_engine, **kwargs):  # noqa: E501
        """change_vpsa_zadara_engine  # noqa: E501

        Change a VPSA's Zadara Engine.  # 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_vpsa_zadara_engine(vpsa_id, change_vpsa_zadara_engine, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param ChangeVpsaZadaraEngine change_vpsa_zadara_engine: (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_vpsa_zadara_engine_with_http_info(vpsa_id, change_vpsa_zadara_engine, **kwargs)  # noqa: E501
        else:
            (data) = self.change_vpsa_zadara_engine_with_http_info(vpsa_id, change_vpsa_zadara_engine, **kwargs)  # noqa: E501
            return data

    def change_vpsa_zadara_engine_with_http_info(self, vpsa_id, change_vpsa_zadara_engine, **kwargs):  # noqa: E501
        """change_vpsa_zadara_engine  # noqa: E501

        Change a VPSA's Zadara Engine.  # 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_vpsa_zadara_engine_with_http_info(vpsa_id, change_vpsa_zadara_engine, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param ChangeVpsaZadaraEngine change_vpsa_zadara_engine: (required)
        :return: InlineResponse20029
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id', 'change_vpsa_zadara_engine']  # 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_vpsa_zadara_engine" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `change_vpsa_zadara_engine`")  # noqa: E501
        # verify the required parameter 'change_vpsa_zadara_engine' is set
        if self.api_client.client_side_validation and ('change_vpsa_zadara_engine' not in params or
                                                       params['change_vpsa_zadara_engine'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `change_vpsa_zadara_engine` when calling `change_vpsa_zadara_engine`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `change_vpsa_zadara_engine`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'change_vpsa_zadara_engine' in params:
            body_params = params['change_vpsa_zadara_engine']
        # 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(
            '/vpsas/{vpsa_id}/engine.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 create_object_storage_account(self, vpsa_id, create_object_storage_account, **kwargs):  # noqa: E501
        """create_object_storage_account  # noqa: E501

        Create a new object storage account.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_object_storage_account(vpsa_id, create_object_storage_account, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param CreateObjectStorageAccount create_object_storage_account: (required)
        :return: InlineResponse20048
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_object_storage_account_with_http_info(vpsa_id, create_object_storage_account, **kwargs)  # noqa: E501
        else:
            (data) = self.create_object_storage_account_with_http_info(vpsa_id, create_object_storage_account, **kwargs)  # noqa: E501
            return data

    def create_object_storage_account_with_http_info(self, vpsa_id, create_object_storage_account, **kwargs):  # noqa: E501
        """create_object_storage_account  # noqa: E501

        Create a new object storage account.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_object_storage_account_with_http_info(vpsa_id, create_object_storage_account, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param CreateObjectStorageAccount create_object_storage_account: (required)
        :return: InlineResponse20048
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id', 'create_object_storage_account']  # 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 create_object_storage_account" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `create_object_storage_account`")  # noqa: E501
        # verify the required parameter 'create_object_storage_account' is set
        if self.api_client.client_side_validation and ('create_object_storage_account' not in params or
                                                       params['create_object_storage_account'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `create_object_storage_account` when calling `create_object_storage_account`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `create_object_storage_account`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_object_storage_account' in params:
            body_params = params['create_object_storage_account']
        # 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(
            '/vpsas/{vpsa_id}/accounts.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20048',  # 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 create_vpsa(self, create_vpsa, **kwargs):  # noqa: E501
        """create_vpsa  # noqa: E501

        Create a VPSA Storage Array or 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.create_vpsa(create_vpsa, async_req=True)
        >>> result = thread.get()

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

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

        Create a VPSA Storage Array or 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.create_vpsa_with_http_info(create_vpsa, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateVpsa create_vpsa: (required)
        :return: InlineResponse20026
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['create_vpsa']  # 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 create_vpsa" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'create_vpsa' is set
        if self.api_client.client_side_validation and ('create_vpsa' not in params or
                                                       params['create_vpsa'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `create_vpsa` when calling `create_vpsa`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_vpsa' in params:
            body_params = params['create_vpsa']
        # 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(
            '/vpsas.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20026',  # 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 delete_vpsa(self, vpsa_id, **kwargs):  # noqa: E501
        """delete_vpsa  # noqa: E501

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

        :param async_req bool
        :param str vpsa_id: (required)
        :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.delete_vpsa_with_http_info(vpsa_id, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_vpsa_with_http_info(vpsa_id, **kwargs)  # noqa: E501
            return data

    def delete_vpsa_with_http_info(self, vpsa_id, **kwargs):  # noqa: E501
        """delete_vpsa  # noqa: E501

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

        :param async_req bool
        :param str vpsa_id: (required)
        :return: InlineResponse20028
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id']  # 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 delete_vpsa" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `delete_vpsa`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `delete_vpsa`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        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(
            '/vpsas/{vpsa_id}.json', 'DELETE',
            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 disable_object_account_servce_from_vpsa_object_storage(self, vpsa_id, **kwargs):  # noqa: E501
        """disable_object_account_servce_from_vpsa_object_storage  # noqa: E501

        Disable object account service from an existing 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.disable_object_account_servce_from_vpsa_object_storage(vpsa_id, async_req=True)
        >>> result = thread.get()

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

    def disable_object_account_servce_from_vpsa_object_storage_with_http_info(self, vpsa_id, **kwargs):  # noqa: E501
        """disable_object_account_servce_from_vpsa_object_storage  # noqa: E501

        Disable object account service from an existing 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.disable_object_account_servce_from_vpsa_object_storage_with_http_info(vpsa_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :return: InlineResponse20046
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id']  # 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_object_account_servce_from_vpsa_object_storage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `disable_object_account_servce_from_vpsa_object_storage`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `disable_object_account_servce_from_vpsa_object_storage`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        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(
            '/vpsas/{vpsa_id}/public_zios.json', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20046',  # 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 disables_data_reduction_bundle_on_flash_vpsa(self, vpsa_id, **kwargs):  # noqa: E501
        """disables_data_reduction_bundle_on_flash_vpsa  # noqa: E501

        Disables data reduction bundle on a Flash VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disables_data_reduction_bundle_on_flash_vpsa(vpsa_id, async_req=True)
        >>> result = thread.get()

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

    def disables_data_reduction_bundle_on_flash_vpsa_with_http_info(self, vpsa_id, **kwargs):  # noqa: E501
        """disables_data_reduction_bundle_on_flash_vpsa  # noqa: E501

        Disables data reduction bundle on a Flash VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disables_data_reduction_bundle_on_flash_vpsa_with_http_info(vpsa_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :return: InlineResponse20042
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id']  # 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 disables_data_reduction_bundle_on_flash_vpsa" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `disables_data_reduction_bundle_on_flash_vpsa`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `disables_data_reduction_bundle_on_flash_vpsa`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        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(
            '/vpsas/{vpsa_id}/disable_data_reduction_bundle.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20042',  # 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 enable_object_account_servce_for_vpsa_object_storage(self, vpsa_id, enable_object_account, **kwargs):  # noqa: E501
        """enable_object_account_servce_for_vpsa_object_storage  # noqa: E501

        Enable object account service for an existing 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.enable_object_account_servce_for_vpsa_object_storage(vpsa_id, enable_object_account, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param EnableObjectAccount enable_object_account: (required)
        :return: InlineResponse20045
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.enable_object_account_servce_for_vpsa_object_storage_with_http_info(vpsa_id, enable_object_account, **kwargs)  # noqa: E501
        else:
            (data) = self.enable_object_account_servce_for_vpsa_object_storage_with_http_info(vpsa_id, enable_object_account, **kwargs)  # noqa: E501
            return data

    def enable_object_account_servce_for_vpsa_object_storage_with_http_info(self, vpsa_id, enable_object_account, **kwargs):  # noqa: E501
        """enable_object_account_servce_for_vpsa_object_storage  # noqa: E501

        Enable object account service for an existing 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.enable_object_account_servce_for_vpsa_object_storage_with_http_info(vpsa_id, enable_object_account, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param EnableObjectAccount enable_object_account: (required)
        :return: InlineResponse20045
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id', 'enable_object_account']  # 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 enable_object_account_servce_for_vpsa_object_storage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `enable_object_account_servce_for_vpsa_object_storage`")  # noqa: E501
        # verify the required parameter 'enable_object_account' is set
        if self.api_client.client_side_validation and ('enable_object_account' not in params or
                                                       params['enable_object_account'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `enable_object_account` when calling `enable_object_account_servce_for_vpsa_object_storage`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `enable_object_account_servce_for_vpsa_object_storage`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'enable_object_account' in params:
            body_params = params['enable_object_account']
        # 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(
            '/vpsas/{vpsa_id}/public_zios.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20045',  # 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 enables_data_reduction_bundle_on_flash_vpsa(self, vpsa_id, **kwargs):  # noqa: E501
        """enables_data_reduction_bundle_on_flash_vpsa  # noqa: E501

        Enables data reduction bundle on a Flash VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enables_data_reduction_bundle_on_flash_vpsa(vpsa_id, async_req=True)
        >>> result = thread.get()

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

    def enables_data_reduction_bundle_on_flash_vpsa_with_http_info(self, vpsa_id, **kwargs):  # noqa: E501
        """enables_data_reduction_bundle_on_flash_vpsa  # noqa: E501

        Enables data reduction bundle on a Flash VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enables_data_reduction_bundle_on_flash_vpsa_with_http_info(vpsa_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :return: InlineResponse20041
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id']  # 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 enables_data_reduction_bundle_on_flash_vpsa" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `enables_data_reduction_bundle_on_flash_vpsa`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `enables_data_reduction_bundle_on_flash_vpsa`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        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(
            '/vpsas/{vpsa_id}/enable_data_reduction.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20041',  # 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_object_account_servce_for_vpsa_object_storage(self, vpsa_id, **kwargs):  # noqa: E501
        """get_object_account_servce_for_vpsa_object_storage  # noqa: E501

        Get object account service for an existing 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.get_object_account_servce_for_vpsa_object_storage(vpsa_id, async_req=True)
        >>> result = thread.get()

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

    def get_object_account_servce_for_vpsa_object_storage_with_http_info(self, vpsa_id, **kwargs):  # noqa: E501
        """get_object_account_servce_for_vpsa_object_storage  # noqa: E501

        Get object account service for an existing 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.get_object_account_servce_for_vpsa_object_storage_with_http_info(vpsa_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :return: InlineResponse20043
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id']  # 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_object_account_servce_for_vpsa_object_storage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `get_object_account_servce_for_vpsa_object_storage`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `get_object_account_servce_for_vpsa_object_storage`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        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(
            '/vpsas/{vpsa_id}/public_zios.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20043',  # 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_object_storage_account_info(self, vpsa_id, account_id, **kwargs):  # noqa: E501
        """get_object_storage_account_info  # noqa: E501

        Get an object storage account 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_object_storage_account_info(vpsa_id, account_id, async_req=True)
        >>> result = thread.get()

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

    def get_object_storage_account_info_with_http_info(self, vpsa_id, account_id, **kwargs):  # noqa: E501
        """get_object_storage_account_info  # noqa: E501

        Get an object storage account 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_object_storage_account_info_with_http_info(vpsa_id, account_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param str account_id: (required)
        :return: InlineResponse20049
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id', 'account_id']  # 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_object_storage_account_info" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `get_object_storage_account_info`")  # noqa: E501
        # verify the required parameter 'account_id' is set
        if self.api_client.client_side_validation and ('account_id' not in params or
                                                       params['account_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `account_id` when calling `get_object_storage_account_info`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `get_object_storage_account_info`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501
        if 'account_id' in params:
            path_params['account_id'] = params['account_id']  # noqa: E501

        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(
            '/vpsas/{vpsa_id}/accounts/{account_id}.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20049',  # 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_vpsa_information(self, vpsa_id, **kwargs):  # noqa: E501
        """get_vpsa_information  # noqa: E501

        Retrieve information about a single VPSA.  # 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_vpsa_information(vpsa_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :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_vpsa_information_with_http_info(vpsa_id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_vpsa_information_with_http_info(vpsa_id, **kwargs)  # noqa: E501
            return data

    def get_vpsa_information_with_http_info(self, vpsa_id, **kwargs):  # noqa: E501
        """get_vpsa_information  # noqa: E501

        Retrieve information about a single VPSA.  # 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_vpsa_information_with_http_info(vpsa_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :return: InlineResponse20027
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id']  # 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_vpsa_information" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `get_vpsa_information`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `get_vpsa_information`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        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(
            '/vpsas/{vpsa_id}.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_vpsas_info(self, **kwargs):  # noqa: E501
        """get_vpsas_info  # noqa: E501

        Retrieve information about all of your VPSAs.  # 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_vpsas_info(async_req=True)
        >>> result = thread.get()

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

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

        Retrieve information about all of your VPSAs.  # 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_vpsas_info_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: InlineResponse20025
                 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_vpsas_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(
            '/vpsas.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20025',  # 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 hibernate_vpsa(self, vpsa_id, **kwargs):  # noqa: E501
        """hibernate_vpsa  # noqa: E501

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

        :param async_req bool
        :param str vpsa_id: (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.hibernate_vpsa_with_http_info(vpsa_id, **kwargs)  # noqa: E501
        else:
            (data) = self.hibernate_vpsa_with_http_info(vpsa_id, **kwargs)  # noqa: E501
            return data

    def hibernate_vpsa_with_http_info(self, vpsa_id, **kwargs):  # noqa: E501
        """hibernate_vpsa  # noqa: E501

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

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

        all_params = ['vpsa_id']  # 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 hibernate_vpsa" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `hibernate_vpsa`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `hibernate_vpsa`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        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(
            '/vpsas/{vpsa_id}/hibernate.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 list_compatible_vni_for_vpsa(self, vpsa_id, **kwargs):  # noqa: E501
        """list_compatible_vni_for_vpsa  # noqa: E501

        Return a list of compatible Virtual Network Interface for a VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_compatible_vni_for_vpsa(vpsa_id, async_req=True)
        >>> result = thread.get()

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

    def list_compatible_vni_for_vpsa_with_http_info(self, vpsa_id, **kwargs):  # noqa: E501
        """list_compatible_vni_for_vpsa  # noqa: E501

        Return a list of compatible Virtual Network Interface for a VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_compatible_vni_for_vpsa_with_http_info(vpsa_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :return: InlineResponse20038
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id']  # 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 list_compatible_vni_for_vpsa" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `list_compatible_vni_for_vpsa`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `list_compatible_vni_for_vpsa`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        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(
            '/vpsas/{vpsa_id}/compatible_vnis.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20038',  # 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 list_object_storage_accounts_of_vpsa(self, vpsa_id, **kwargs):  # noqa: E501
        """list_object_storage_accounts_of_vpsa  # noqa: E501

        Get all object storage accounts for a given 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.list_object_storage_accounts_of_vpsa(vpsa_id, async_req=True)
        >>> result = thread.get()

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

    def list_object_storage_accounts_of_vpsa_with_http_info(self, vpsa_id, **kwargs):  # noqa: E501
        """list_object_storage_accounts_of_vpsa  # noqa: E501

        Get all object storage accounts for a given 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.list_object_storage_accounts_of_vpsa_with_http_info(vpsa_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :return: InlineResponse20047
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id']  # 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 list_object_storage_accounts_of_vpsa" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `list_object_storage_accounts_of_vpsa`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `list_object_storage_accounts_of_vpsa`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        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(
            '/vpsas/{vpsa_id}/accounts.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20047',  # 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 maintenance_mode(self, vpsa_id, maintenance_mode, **kwargs):  # noqa: E501
        """maintenance_mode  # noqa: E501

        Enter or exit maintenance mode 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.maintenance_mode(vpsa_id, maintenance_mode, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param MaintenanceMode maintenance_mode: (required)
        :return: InlineResponse20034
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.maintenance_mode_with_http_info(vpsa_id, maintenance_mode, **kwargs)  # noqa: E501
        else:
            (data) = self.maintenance_mode_with_http_info(vpsa_id, maintenance_mode, **kwargs)  # noqa: E501
            return data

    def maintenance_mode_with_http_info(self, vpsa_id, maintenance_mode, **kwargs):  # noqa: E501
        """maintenance_mode  # noqa: E501

        Enter or exit maintenance mode 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.maintenance_mode_with_http_info(vpsa_id, maintenance_mode, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param MaintenanceMode maintenance_mode: (required)
        :return: InlineResponse20034
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id', 'maintenance_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 maintenance_mode" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `maintenance_mode`")  # noqa: E501
        # verify the required parameter 'maintenance_mode' is set
        if self.api_client.client_side_validation and ('maintenance_mode' not in params or
                                                       params['maintenance_mode'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `maintenance_mode` when calling `maintenance_mode`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `maintenance_mode`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'maintenance_mode' in params:
            body_params = params['maintenance_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(
            '/vpsas/{vpsa_id}/maintenance_mode.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20034',  # 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 remove_account_from_vpsa_object_storage(self, vpsa_id, account_id, **kwargs):  # noqa: E501
        """remove_account_from_vpsa_object_storage  # noqa: E501

        Generates a request to remove an object storage account from a 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.remove_account_from_vpsa_object_storage(vpsa_id, account_id, async_req=True)
        >>> result = thread.get()

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

    def remove_account_from_vpsa_object_storage_with_http_info(self, vpsa_id, account_id, **kwargs):  # noqa: E501
        """remove_account_from_vpsa_object_storage  # noqa: E501

        Generates a request to remove an object storage account from a 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.remove_account_from_vpsa_object_storage_with_http_info(vpsa_id, account_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param str account_id: (required)
        :return: InlineResponse20050
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id', 'account_id']  # 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 remove_account_from_vpsa_object_storage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `remove_account_from_vpsa_object_storage`")  # noqa: E501
        # verify the required parameter 'account_id' is set
        if self.api_client.client_side_validation and ('account_id' not in params or
                                                       params['account_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `account_id` when calling `remove_account_from_vpsa_object_storage`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `remove_account_from_vpsa_object_storage`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501
        if 'account_id' in params:
            path_params['account_id'] = params['account_id']  # noqa: E501

        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(
            '/vpsas/{vpsa_id}/accounts/{account_id}.json', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20050',  # 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 remove_vni_from_vpsa(self, vpsa_id, remove_vni_from_vpsa, **kwargs):  # noqa: E501
        """remove_vni_from_vpsa  # noqa: E501

        Remove a Virtual Network Interface from a VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_vni_from_vpsa(vpsa_id, remove_vni_from_vpsa, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param RemoveVniFromVpsa remove_vni_from_vpsa: (required)
        :return: InlineResponse20040
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.remove_vni_from_vpsa_with_http_info(vpsa_id, remove_vni_from_vpsa, **kwargs)  # noqa: E501
        else:
            (data) = self.remove_vni_from_vpsa_with_http_info(vpsa_id, remove_vni_from_vpsa, **kwargs)  # noqa: E501
            return data

    def remove_vni_from_vpsa_with_http_info(self, vpsa_id, remove_vni_from_vpsa, **kwargs):  # noqa: E501
        """remove_vni_from_vpsa  # noqa: E501

        Remove a Virtual Network Interface from a VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_vni_from_vpsa_with_http_info(vpsa_id, remove_vni_from_vpsa, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param RemoveVniFromVpsa remove_vni_from_vpsa: (required)
        :return: InlineResponse20040
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id', 'remove_vni_from_vpsa']  # 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 remove_vni_from_vpsa" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `remove_vni_from_vpsa`")  # noqa: E501
        # verify the required parameter 'remove_vni_from_vpsa' is set
        if self.api_client.client_side_validation and ('remove_vni_from_vpsa' not in params or
                                                       params['remove_vni_from_vpsa'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `remove_vni_from_vpsa` when calling `remove_vni_from_vpsa`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `remove_vni_from_vpsa`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'remove_vni_from_vpsa' in params:
            body_params = params['remove_vni_from_vpsa']
        # 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(
            '/vpsas/{vpsa_id}/remove_vni.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20040',  # 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 remove_vpsa_public_ip(self, vpsa_id, **kwargs):  # noqa: E501
        """remove_vpsa_public_ip  # noqa: E501

        Remove a public IP from a VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_vpsa_public_ip(vpsa_id, async_req=True)
        >>> result = thread.get()

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

    def remove_vpsa_public_ip_with_http_info(self, vpsa_id, **kwargs):  # noqa: E501
        """remove_vpsa_public_ip  # noqa: E501

        Remove a public IP from a VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_vpsa_public_ip_with_http_info(vpsa_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :return: InlineResponse20037
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id']  # 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 remove_vpsa_public_ip" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `remove_vpsa_public_ip`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `remove_vpsa_public_ip`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        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(
            '/vpsas/{vpsa_id}/public_ip.json', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20037',  # 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 resume_vpsa(self, vpsa_id, **kwargs):  # noqa: E501
        """resume_vpsa  # noqa: E501

        Restore a VPSA from hibernating state.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.resume_vpsa(vpsa_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (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.resume_vpsa_with_http_info(vpsa_id, **kwargs)  # noqa: E501
        else:
            (data) = self.resume_vpsa_with_http_info(vpsa_id, **kwargs)  # noqa: E501
            return data

    def resume_vpsa_with_http_info(self, vpsa_id, **kwargs):  # noqa: E501
        """resume_vpsa  # noqa: E501

        Restore a VPSA from hibernating state.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.resume_vpsa_with_http_info(vpsa_id, async_req=True)
        >>> result = thread.get()

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

        all_params = ['vpsa_id']  # 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 resume_vpsa" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `resume_vpsa`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `resume_vpsa`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        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(
            '/vpsas/{vpsa_id}/restore.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 update_object_account_service_for_vpsa_object_storage(self, vpsa_id, update_object_account, **kwargs):  # noqa: E501
        """update_object_account_service_for_vpsa_object_storage  # noqa: E501

        Update object account service on an existing 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.update_object_account_service_for_vpsa_object_storage(vpsa_id, update_object_account, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param UpdateObjectAccount update_object_account: (required)
        :return: InlineResponse20044
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_object_account_service_for_vpsa_object_storage_with_http_info(vpsa_id, update_object_account, **kwargs)  # noqa: E501
        else:
            (data) = self.update_object_account_service_for_vpsa_object_storage_with_http_info(vpsa_id, update_object_account, **kwargs)  # noqa: E501
            return data

    def update_object_account_service_for_vpsa_object_storage_with_http_info(self, vpsa_id, update_object_account, **kwargs):  # noqa: E501
        """update_object_account_service_for_vpsa_object_storage  # noqa: E501

        Update object account service on an existing 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.update_object_account_service_for_vpsa_object_storage_with_http_info(vpsa_id, update_object_account, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str vpsa_id: (required)
        :param UpdateObjectAccount update_object_account: (required)
        :return: InlineResponse20044
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['vpsa_id', 'update_object_account']  # 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 update_object_account_service_for_vpsa_object_storage" % key
                )
            params[key] = val
        del params['kwargs']
        # verify the required parameter 'vpsa_id' is set
        if self.api_client.client_side_validation and ('vpsa_id' not in params or
                                                       params['vpsa_id'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `vpsa_id` when calling `update_object_account_service_for_vpsa_object_storage`")  # noqa: E501
        # verify the required parameter 'update_object_account' is set
        if self.api_client.client_side_validation and ('update_object_account' not in params or
                                                       params['update_object_account'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `update_object_account` when calling `update_object_account_service_for_vpsa_object_storage`")  # noqa: E501

        if self.api_client.client_side_validation and ('vpsa_id' in params and not re.search(r'vsa-[0-9a-z]+|[0-9]+', params['vpsa_id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `vpsa_id` when calling `update_object_account_service_for_vpsa_object_storage`, must conform to the pattern `/vsa-[0-9a-z]+|[0-9]+/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'vpsa_id' in params:
            path_params['vpsa_id'] = params['vpsa_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'update_object_account' in params:
            body_params = params['update_object_account']
        # 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(
            '/vpsas/{vpsa_id}/public_zios.json', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20044',  # 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)
