# coding: utf-8

"""
    Command Center operations

    Command Center operations  # 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 CommandCenter.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_drives(self, cloud_name, id, add_drives, **kwargs):  # noqa: E501
        """add_drives  # noqa: E501

        Add drives to 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_drives(cloud_name, id, add_drives, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: The cloud 'name' as returned by get_all_clouds. example zadaralab01 (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param AddDrives add_drives: (required)
        :return: InlineResponse20094
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.add_drives_with_http_info(cloud_name, id, add_drives, **kwargs)  # noqa: E501
        else:
            (data) = self.add_drives_with_http_info(cloud_name, id, add_drives, **kwargs)  # noqa: E501
            return data

    def add_drives_with_http_info(self, cloud_name, id, add_drives, **kwargs):  # noqa: E501
        """add_drives  # noqa: E501

        Add drives to 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_drives_with_http_info(cloud_name, id, add_drives, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: The cloud 'name' as returned by get_all_clouds. example zadaralab01 (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param AddDrives add_drives: (required)
        :return: InlineResponse20094
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'add_drives' in params:
            body_params = params['add_drives']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/drives.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20094',  # 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_interface(self, cloud_name, id, add_virtual_network_interface, **kwargs):  # noqa: E501
        """add_virtual_network_interface  # noqa: E501

        Add Virtual Network to 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_interface(cloud_name, id, add_virtual_network_interface, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param AddVirtualNetworkInterface add_virtual_network_interface: (required)
        :return: InlineResponse2004
                 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_interface_with_http_info(cloud_name, id, add_virtual_network_interface, **kwargs)  # noqa: E501
        else:
            (data) = self.add_virtual_network_interface_with_http_info(cloud_name, id, add_virtual_network_interface, **kwargs)  # noqa: E501
            return data

    def add_virtual_network_interface_with_http_info(self, cloud_name, id, add_virtual_network_interface, **kwargs):  # noqa: E501
        """add_virtual_network_interface  # noqa: E501

        Add Virtual Network to 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_interface_with_http_info(cloud_name, id, add_virtual_network_interface, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param AddVirtualNetworkInterface add_virtual_network_interface: (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/clouds/{cloud_name}/vpsas/{id}/add_virtual_network_interface.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2004',  # 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_vpsa_endpoints_conf_for_upload_types(self, cloud_name, id, add_vpsa_endpoints_conf_for_upload_types, **kwargs):  # noqa: E501
        """add_vpsa_endpoints_conf_for_upload_types  # noqa: E501

        Adds more vpsa endpoints configurations for upload type  # 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_vpsa_endpoints_conf_for_upload_types(cloud_name, id, add_vpsa_endpoints_conf_for_upload_types, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param AddVpsaEndpointsConfForUploadTypes add_vpsa_endpoints_conf_for_upload_types: (required)
        :return: InlineResponse200123
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.add_vpsa_endpoints_conf_for_upload_types_with_http_info(cloud_name, id, add_vpsa_endpoints_conf_for_upload_types, **kwargs)  # noqa: E501
        else:
            (data) = self.add_vpsa_endpoints_conf_for_upload_types_with_http_info(cloud_name, id, add_vpsa_endpoints_conf_for_upload_types, **kwargs)  # noqa: E501
            return data

    def add_vpsa_endpoints_conf_for_upload_types_with_http_info(self, cloud_name, id, add_vpsa_endpoints_conf_for_upload_types, **kwargs):  # noqa: E501
        """add_vpsa_endpoints_conf_for_upload_types  # noqa: E501

        Adds more vpsa endpoints configurations for upload type  # 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_vpsa_endpoints_conf_for_upload_types_with_http_info(cloud_name, id, add_vpsa_endpoints_conf_for_upload_types, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param AddVpsaEndpointsConfForUploadTypes add_vpsa_endpoints_conf_for_upload_types: (required)
        :return: InlineResponse200123
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'add_vpsa_endpoints_conf_for_upload_types' in params:
            body_params = params['add_vpsa_endpoints_conf_for_upload_types']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/endpoints_config.json', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200123',  # 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 allocate_networks_for_vpsa(self, cloud_name, id, **kwargs):  # noqa: E501
        """allocate_networks_for_vpsa  # noqa: E501

        Allocate networks for 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.allocate_networks_for_vpsa(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200108
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.allocate_networks_for_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.allocate_networks_for_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def allocate_networks_for_vpsa_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """allocate_networks_for_vpsa  # noqa: E501

        Allocate networks for 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.allocate_networks_for_vpsa_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200108
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/allocate_networks.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200108',  # 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(self, cloud_name, id, assign_public_ip, **kwargs):  # noqa: E501
        """assign_public_ip  # noqa: E501

        Assign public ip to 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(cloud_name, id, assign_public_ip, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param AssignPublicIp assign_public_ip: (required)
        :return: InlineResponse200103
                 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_with_http_info(cloud_name, id, assign_public_ip, **kwargs)  # noqa: E501
        else:
            (data) = self.assign_public_ip_with_http_info(cloud_name, id, assign_public_ip, **kwargs)  # noqa: E501
            return data

    def assign_public_ip_with_http_info(self, cloud_name, id, assign_public_ip, **kwargs):  # noqa: E501
        """assign_public_ip  # noqa: E501

        Assign public ip to 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_with_http_info(cloud_name, id, assign_public_ip, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param AssignPublicIp assign_public_ip: (required)
        :return: InlineResponse200103
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/clouds/{cloud_name}/vpsas/{id}/public_ip/assign.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200103',  # 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 cancel_failover(self, cloud_name, id, **kwargs):  # noqa: E501
        """cancel_failover  # noqa: E501

        Cancel a Failover.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.cancel_failover(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.cancel_failover_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.cancel_failover_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def cancel_failover_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """cancel_failover  # noqa: E501

        Cancel a Failover.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.cancel_failover_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/cancel_sched_failover.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2004',  # 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 cancel_scheduled_zsnap(self, cloud_name, id, **kwargs):  # noqa: E501
        """cancel_scheduled_zsnap  # noqa: E501

        Cancel a Scheduled Zsnap.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.cancel_scheduled_zsnap(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.cancel_scheduled_zsnap_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.cancel_scheduled_zsnap_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def cancel_scheduled_zsnap_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """cancel_scheduled_zsnap  # noqa: E501

        Cancel a Scheduled Zsnap.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.cancel_scheduled_zsnap_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/cancel_sched_zsnap.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2004',  # 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 cancel_upgrade(self, cloud_name, id, **kwargs):  # noqa: E501
        """cancel_upgrade  # noqa: E501

        Cancel an Upgrade.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.cancel_upgrade(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.cancel_upgrade_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.cancel_upgrade_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def cancel_upgrade_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """cancel_upgrade  # noqa: E501

        Cancel an Upgrade.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.cancel_upgrade_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/cancel_sched_upgrade.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2004',  # 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_cache(self, cloud_name, id, change_cache, **kwargs):  # noqa: E501
        """change_cache  # noqa: E501

        Change VPSA cache.  # 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_cache(cloud_name, id, change_cache, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param ChangeCache change_cache: (required)
        :return: InlineResponse200110
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.change_cache_with_http_info(cloud_name, id, change_cache, **kwargs)  # noqa: E501
        else:
            (data) = self.change_cache_with_http_info(cloud_name, id, change_cache, **kwargs)  # noqa: E501
            return data

    def change_cache_with_http_info(self, cloud_name, id, change_cache, **kwargs):  # noqa: E501
        """change_cache  # noqa: E501

        Change VPSA cache.  # 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_cache_with_http_info(cloud_name, id, change_cache, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param ChangeCache change_cache: (required)
        :return: InlineResponse200110
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'change_cache' in params:
            body_params = params['change_cache']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/change_cache.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200110',  # 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_new_vpsa_upload_endpoint(self, cloud_name, id, create_new_vpsa_upload_endpoint, **kwargs):  # noqa: E501
        """create_new_vpsa_upload_endpoint  # noqa: E501

        Creates a new vpsa upload endpoint  # 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_new_vpsa_upload_endpoint(cloud_name, id, create_new_vpsa_upload_endpoint, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param CreateNewVpsaUploadEndpoint create_new_vpsa_upload_endpoint: (required)
        :return: InlineResponse200120
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_new_vpsa_upload_endpoint_with_http_info(cloud_name, id, create_new_vpsa_upload_endpoint, **kwargs)  # noqa: E501
        else:
            (data) = self.create_new_vpsa_upload_endpoint_with_http_info(cloud_name, id, create_new_vpsa_upload_endpoint, **kwargs)  # noqa: E501
            return data

    def create_new_vpsa_upload_endpoint_with_http_info(self, cloud_name, id, create_new_vpsa_upload_endpoint, **kwargs):  # noqa: E501
        """create_new_vpsa_upload_endpoint  # noqa: E501

        Creates a new vpsa upload endpoint  # 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_new_vpsa_upload_endpoint_with_http_info(cloud_name, id, create_new_vpsa_upload_endpoint, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param CreateNewVpsaUploadEndpoint create_new_vpsa_upload_endpoint: (required)
        :return: InlineResponse200120
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_new_vpsa_upload_endpoint' in params:
            body_params = params['create_new_vpsa_upload_endpoint']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/endpoints.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200120',  # 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_endpoints_conf_for_upload_types(self, cloud_name, id, create_vpsa_endpoints_conf_for_upload_types, **kwargs):  # noqa: E501
        """create_vpsa_endpoints_conf_for_upload_types  # noqa: E501

        Creates vpsa endpoints configurations for upload type  # 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_endpoints_conf_for_upload_types(cloud_name, id, create_vpsa_endpoints_conf_for_upload_types, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param CreateVpsaEndpointsConfForUploadTypes create_vpsa_endpoints_conf_for_upload_types: (required)
        :return: InlineResponse200124
                 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_endpoints_conf_for_upload_types_with_http_info(cloud_name, id, create_vpsa_endpoints_conf_for_upload_types, **kwargs)  # noqa: E501
        else:
            (data) = self.create_vpsa_endpoints_conf_for_upload_types_with_http_info(cloud_name, id, create_vpsa_endpoints_conf_for_upload_types, **kwargs)  # noqa: E501
            return data

    def create_vpsa_endpoints_conf_for_upload_types_with_http_info(self, cloud_name, id, create_vpsa_endpoints_conf_for_upload_types, **kwargs):  # noqa: E501
        """create_vpsa_endpoints_conf_for_upload_types  # noqa: E501

        Creates vpsa endpoints configurations for upload type  # 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_endpoints_conf_for_upload_types_with_http_info(cloud_name, id, create_vpsa_endpoints_conf_for_upload_types, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param CreateVpsaEndpointsConfForUploadTypes create_vpsa_endpoints_conf_for_upload_types: (required)
        :return: InlineResponse200124
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_vpsa_endpoints_conf_for_upload_types' in params:
            body_params = params['create_vpsa_endpoints_conf_for_upload_types']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/endpoints_config.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200124',  # 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_zsnap(self, cloud_name, id, create_zsnap, **kwargs):  # noqa: E501
        """create_zsnap  # noqa: E501

        Create a VPSA Zsnap.  # 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_zsnap(cloud_name, id, create_zsnap, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param CreateZsnap create_zsnap: (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.create_zsnap_with_http_info(cloud_name, id, create_zsnap, **kwargs)  # noqa: E501
        else:
            (data) = self.create_zsnap_with_http_info(cloud_name, id, create_zsnap, **kwargs)  # noqa: E501
            return data

    def create_zsnap_with_http_info(self, cloud_name, id, create_zsnap, **kwargs):  # noqa: E501
        """create_zsnap  # noqa: E501

        Create a VPSA Zsnap.  # 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_zsnap_with_http_info(cloud_name, id, create_zsnap, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param CreateZsnap create_zsnap: (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_zsnap' in params:
            body_params = params['create_zsnap']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/zsnap.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2004',  # 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_endpoints_conf_for_upload_types(self, cloud_name, id, delete_vpsa_endpoints_conf_for_upload_types, **kwargs):  # noqa: E501
        """delete_vpsa_endpoints_conf_for_upload_types  # noqa: E501

        Deletes an existing vpsa endpoint configuration for upload type  # 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_endpoints_conf_for_upload_types(cloud_name, id, delete_vpsa_endpoints_conf_for_upload_types, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param DeleteVpsaEndpointsConfForUploadTypes delete_vpsa_endpoints_conf_for_upload_types: (required)
        :return: InlineResponse200125
                 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_endpoints_conf_for_upload_types_with_http_info(cloud_name, id, delete_vpsa_endpoints_conf_for_upload_types, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_vpsa_endpoints_conf_for_upload_types_with_http_info(cloud_name, id, delete_vpsa_endpoints_conf_for_upload_types, **kwargs)  # noqa: E501
            return data

    def delete_vpsa_endpoints_conf_for_upload_types_with_http_info(self, cloud_name, id, delete_vpsa_endpoints_conf_for_upload_types, **kwargs):  # noqa: E501
        """delete_vpsa_endpoints_conf_for_upload_types  # noqa: E501

        Deletes an existing vpsa endpoint configuration for upload type  # 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_endpoints_conf_for_upload_types_with_http_info(cloud_name, id, delete_vpsa_endpoints_conf_for_upload_types, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param DeleteVpsaEndpointsConfForUploadTypes delete_vpsa_endpoints_conf_for_upload_types: (required)
        :return: InlineResponse200125
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'delete_vpsa_endpoints_conf_for_upload_types' in params:
            body_params = params['delete_vpsa_endpoints_conf_for_upload_types']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/endpoints_config.json', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200125',  # 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_upload_endpoint(self, cloud_name, id, delete_vpsa_upload_endpoint, **kwargs):  # noqa: E501
        """delete_vpsa_upload_endpoint  # noqa: E501

        Deletes an existing vpsa upload endpoint  # 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_upload_endpoint(cloud_name, id, delete_vpsa_upload_endpoint, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param DeleteVpsaUploadEndpoint delete_vpsa_upload_endpoint: (required)
        :return: InlineResponse200121
                 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_upload_endpoint_with_http_info(cloud_name, id, delete_vpsa_upload_endpoint, **kwargs)  # noqa: E501
        else:
            (data) = self.delete_vpsa_upload_endpoint_with_http_info(cloud_name, id, delete_vpsa_upload_endpoint, **kwargs)  # noqa: E501
            return data

    def delete_vpsa_upload_endpoint_with_http_info(self, cloud_name, id, delete_vpsa_upload_endpoint, **kwargs):  # noqa: E501
        """delete_vpsa_upload_endpoint  # noqa: E501

        Deletes an existing vpsa upload endpoint  # 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_upload_endpoint_with_http_info(cloud_name, id, delete_vpsa_upload_endpoint, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param DeleteVpsaUploadEndpoint delete_vpsa_upload_endpoint: (required)
        :return: InlineResponse200121
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'delete_vpsa_upload_endpoint' in params:
            body_params = params['delete_vpsa_upload_endpoint']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/endpoints.json', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200121',  # 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_data_reduction_bundle_for_flash_vpsa(self, cloud_name, id, **kwargs):  # noqa: E501
        """disable_data_reduction_bundle_for_flash_vpsa  # noqa: E501

        Disables data reduction bundle for 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.disable_data_reduction_bundle_for_flash_vpsa(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200116
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.disable_data_reduction_bundle_for_flash_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.disable_data_reduction_bundle_for_flash_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def disable_data_reduction_bundle_for_flash_vpsa_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """disable_data_reduction_bundle_for_flash_vpsa  # noqa: E501

        Disables data reduction bundle for 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.disable_data_reduction_bundle_for_flash_vpsa_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200116
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{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='InlineResponse200116',  # 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_flc(self, cloud_name, id, **kwargs):  # noqa: E501
        """disable_flc  # noqa: E501

        Disable file lifecycle management for the given 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.disable_flc(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200114
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.disable_flc_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.disable_flc_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def disable_flc_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """disable_flc  # noqa: E501

        Disable file lifecycle management for the given 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.disable_flc_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200114
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/disable_flc.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200114',  # 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_pool_migration_for_all_flash_array_vpsa(self, cloud_name, id, **kwargs):  # noqa: E501
        """disable_pool_migration_for_all_flash_array_vpsa  # noqa: E501

        Disable pool migratrion for All Flash Array 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.disable_pool_migration_for_all_flash_array_vpsa(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200108
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.disable_pool_migration_for_all_flash_array_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.disable_pool_migration_for_all_flash_array_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def disable_pool_migration_for_all_flash_array_vpsa_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """disable_pool_migration_for_all_flash_array_vpsa  # noqa: E501

        Disable pool migratrion for All Flash Array 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.disable_pool_migration_for_all_flash_array_vpsa_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200108
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/disable_pool_migration.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200108',  # 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_data_reduction_bundle_for_flash_vpsa(self, cloud_name, id, **kwargs):  # noqa: E501
        """enable_data_reduction_bundle_for_flash_vpsa  # noqa: E501

        Enable data reduction bundle for 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.enable_data_reduction_bundle_for_flash_vpsa(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200115
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.enable_data_reduction_bundle_for_flash_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.enable_data_reduction_bundle_for_flash_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def enable_data_reduction_bundle_for_flash_vpsa_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """enable_data_reduction_bundle_for_flash_vpsa  # noqa: E501

        Enable data reduction bundle for 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.enable_data_reduction_bundle_for_flash_vpsa_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200115
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/enable_data_reduction_bundle.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200115',  # 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_flc(self, cloud_name, id, **kwargs):  # noqa: E501
        """enable_flc  # noqa: E501

        Enable file lifecycle management for the given 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.enable_flc(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200113
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.enable_flc_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.enable_flc_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def enable_flc_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """enable_flc  # noqa: E501

        Enable file lifecycle management for the given 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.enable_flc_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200113
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/enable_flc.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200113',  # 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_pool_migration(self, cloud_name, id, **kwargs):  # noqa: E501
        """enable_pool_migration  # noqa: E501

        Enable pool migratrion for All Flash Array 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.enable_pool_migration(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200112
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.enable_pool_migration_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.enable_pool_migration_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def enable_pool_migration_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """enable_pool_migration  # noqa: E501

        Enable pool migratrion for All Flash Array 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.enable_pool_migration_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200112
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/enable_pool_migration.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200112',  # 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 failover_vpsa(self, cloud_name, id, failover_vpsa, **kwargs):  # noqa: E501
        """failover_vpsa  # noqa: E501

        Failover 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.failover_vpsa(cloud_name, id, failover_vpsa, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param FailoverVpsa failover_vpsa: (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.failover_vpsa_with_http_info(cloud_name, id, failover_vpsa, **kwargs)  # noqa: E501
        else:
            (data) = self.failover_vpsa_with_http_info(cloud_name, id, failover_vpsa, **kwargs)  # noqa: E501
            return data

    def failover_vpsa_with_http_info(self, cloud_name, id, failover_vpsa, **kwargs):  # noqa: E501
        """failover_vpsa  # noqa: E501

        Failover 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.failover_vpsa_with_http_info(cloud_name, id, failover_vpsa, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param FailoverVpsa failover_vpsa: (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'failover_vpsa' in params:
            body_params = params['failover_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(
            '/clouds/{cloud_name}/vpsas/{id}/failover.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2004',  # 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_all_vpsa_drives(self, cloud_name, id, **kwargs):  # noqa: E501
        """get_all_vpsa_drives  # noqa: E501

        Returns the list of a VPSA's drives.  # 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_all_vpsa_drives(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: The cloud 'name' as returned by get_all_clouds. example zadaralab01 (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20093
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_all_vpsa_drives_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_all_vpsa_drives_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def get_all_vpsa_drives_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """get_all_vpsa_drives  # noqa: E501

        Returns the list of a VPSA's drives.  # 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_all_vpsa_drives_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: The cloud 'name' as returned by get_all_clouds. example zadaralab01 (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20093
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/drives.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20093',  # 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_all_vpsas(self, cloud_name, **kwargs):  # noqa: E501
        """get_all_vpsas  # noqa: E501

        Returns a list of all 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_all_vpsas(cloud_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int page: The page number to start from.
        :param int per_page: The total number of records to return.
        :return: InlineResponse20091
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_all_vpsas_with_http_info(cloud_name, **kwargs)  # noqa: E501
        else:
            (data) = self.get_all_vpsas_with_http_info(cloud_name, **kwargs)  # noqa: E501
            return data

    def get_all_vpsas_with_http_info(self, cloud_name, **kwargs):  # noqa: E501
        """get_all_vpsas  # noqa: E501

        Returns a list of all 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_all_vpsas_with_http_info(cloud_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int page: The page number to start from.
        :param int per_page: The total number of records to return.
        :return: InlineResponse20091
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []
        if 'page' in params:
            query_params.append(('page', params['page']))  # noqa: E501
        if 'per_page' in params:
            query_params.append(('per_page', params['per_page']))  # noqa: E501

        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(
            '/clouds/{cloud_name}/vpsas.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20091',  # 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_raid_groups(self, cloud_name, id, **kwargs):  # noqa: E501
        """get_raid_groups  # noqa: E501

        Returns the list of a VPSA's RAID Groups.  # 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_raid_groups(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20096
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_raid_groups_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_raid_groups_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def get_raid_groups_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """get_raid_groups  # noqa: E501

        Returns the list of a VPSA's RAID Groups.  # 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_raid_groups_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20096
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/raid_groups.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20096',  # 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_capacity_trend(self, cloud_name, id, get_vpsa_capacity_trend, **kwargs):  # noqa: E501
        """get_vpsa_capacity_trend  # noqa: E501

        Returns the VPSA capacity trend.  # 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_capacity_trend(cloud_name, id, get_vpsa_capacity_trend, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param GetVpsaCapacityTrend get_vpsa_capacity_trend: (required)
        :return: InlineResponse200100
                 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_capacity_trend_with_http_info(cloud_name, id, get_vpsa_capacity_trend, **kwargs)  # noqa: E501
        else:
            (data) = self.get_vpsa_capacity_trend_with_http_info(cloud_name, id, get_vpsa_capacity_trend, **kwargs)  # noqa: E501
            return data

    def get_vpsa_capacity_trend_with_http_info(self, cloud_name, id, get_vpsa_capacity_trend, **kwargs):  # noqa: E501
        """get_vpsa_capacity_trend  # noqa: E501

        Returns the VPSA capacity trend.  # 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_capacity_trend_with_http_info(cloud_name, id, get_vpsa_capacity_trend, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param GetVpsaCapacityTrend get_vpsa_capacity_trend: (required)
        :return: InlineResponse200100
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'get_vpsa_capacity_trend' in params:
            body_params = params['get_vpsa_capacity_trend']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/capacity_trend.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200100',  # 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_endpoint_configs_by_upload_types(self, cloud_name, id, get_vpsa_endpoint_configs_by_upload_types, **kwargs):  # noqa: E501
        """get_vpsa_endpoint_configs_by_upload_types  # noqa: E501

        Gets vpsa endpoint configs by upload types  # 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_endpoint_configs_by_upload_types(cloud_name, id, get_vpsa_endpoint_configs_by_upload_types, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param GetVpsaEndpointConfigsByUploadTypes get_vpsa_endpoint_configs_by_upload_types: (required)
        :return: InlineResponse200122
                 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_endpoint_configs_by_upload_types_with_http_info(cloud_name, id, get_vpsa_endpoint_configs_by_upload_types, **kwargs)  # noqa: E501
        else:
            (data) = self.get_vpsa_endpoint_configs_by_upload_types_with_http_info(cloud_name, id, get_vpsa_endpoint_configs_by_upload_types, **kwargs)  # noqa: E501
            return data

    def get_vpsa_endpoint_configs_by_upload_types_with_http_info(self, cloud_name, id, get_vpsa_endpoint_configs_by_upload_types, **kwargs):  # noqa: E501
        """get_vpsa_endpoint_configs_by_upload_types  # noqa: E501

        Gets vpsa endpoint configs by upload types  # 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_endpoint_configs_by_upload_types_with_http_info(cloud_name, id, get_vpsa_endpoint_configs_by_upload_types, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param GetVpsaEndpointConfigsByUploadTypes get_vpsa_endpoint_configs_by_upload_types: (required)
        :return: InlineResponse200122
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'get_vpsa_endpoint_configs_by_upload_types' in params:
            body_params = params['get_vpsa_endpoint_configs_by_upload_types']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/endpoints_config.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200122',  # 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_from_cloud(self, cloud_name, id, **kwargs):  # noqa: E501
        """get_vpsa_from_cloud  # noqa: E501

        Returns the details for 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_from_cloud(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20092
                 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_from_cloud_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_vpsa_from_cloud_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def get_vpsa_from_cloud_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """get_vpsa_from_cloud  # noqa: E501

        Returns the details for 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_from_cloud_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20092
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20092',  # 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_settings(self, cloud_name, id, get_vpsa_settings, **kwargs):  # noqa: E501
        """get_vpsa_settings  # noqa: E501

        Returns VPSA info from Cloud  # 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_settings(cloud_name, id, get_vpsa_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param GetVpsaSettings get_vpsa_settings: (required)
        :return: InlineResponse200122
                 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_settings_with_http_info(cloud_name, id, get_vpsa_settings, **kwargs)  # noqa: E501
        else:
            (data) = self.get_vpsa_settings_with_http_info(cloud_name, id, get_vpsa_settings, **kwargs)  # noqa: E501
            return data

    def get_vpsa_settings_with_http_info(self, cloud_name, id, get_vpsa_settings, **kwargs):  # noqa: E501
        """get_vpsa_settings  # noqa: E501

        Returns VPSA info from Cloud  # 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_settings_with_http_info(cloud_name, id, get_vpsa_settings, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param GetVpsaSettings get_vpsa_settings: (required)
        :return: InlineResponse200122
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'get_vpsa_settings' in params:
            body_params = params['get_vpsa_settings']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/settings.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200122',  # 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 hibrenate_vpsa(self, cloud_name, id, **kwargs):  # noqa: E501
        """hibrenate_vpsa  # noqa: E501

        Hibernate 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.hibrenate_vpsa(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200105
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.hibrenate_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.hibrenate_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def hibrenate_vpsa_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """hibrenate_vpsa  # noqa: E501

        Hibernate 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.hibrenate_vpsa_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200105
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/hibernate.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200105',  # 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_all_vpsa_upload_endpoints(self, cloud_name, id, list_all_vpsa_upload_endpoints, **kwargs):  # noqa: E501
        """list_all_vpsa_upload_endpoints  # noqa: E501

        Gets all vpsa upload endpoints including default endpoints  # 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_all_vpsa_upload_endpoints(cloud_name, id, list_all_vpsa_upload_endpoints, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param ListAllVpsaUploadEndpoints list_all_vpsa_upload_endpoints: (required)
        :return: InlineResponse200118
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_all_vpsa_upload_endpoints_with_http_info(cloud_name, id, list_all_vpsa_upload_endpoints, **kwargs)  # noqa: E501
        else:
            (data) = self.list_all_vpsa_upload_endpoints_with_http_info(cloud_name, id, list_all_vpsa_upload_endpoints, **kwargs)  # noqa: E501
            return data

    def list_all_vpsa_upload_endpoints_with_http_info(self, cloud_name, id, list_all_vpsa_upload_endpoints, **kwargs):  # noqa: E501
        """list_all_vpsa_upload_endpoints  # noqa: E501

        Gets all vpsa upload endpoints including default endpoints  # 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_all_vpsa_upload_endpoints_with_http_info(cloud_name, id, list_all_vpsa_upload_endpoints, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param ListAllVpsaUploadEndpoints list_all_vpsa_upload_endpoints: (required)
        :return: InlineResponse200118
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'list_all_vpsa_upload_endpoints' in params:
            body_params = params['list_all_vpsa_upload_endpoints']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/endpoints.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200118',  # 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_availiable_virtual_nets_to_add_vpsa(self, cloud_name, id, **kwargs):  # noqa: E501
        """list_availiable_virtual_nets_to_add_vpsa  # noqa: E501

        Returns the list of a available Virtual Networks to be added to 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_availiable_virtual_nets_to_add_vpsa(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20098
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_availiable_virtual_nets_to_add_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_availiable_virtual_nets_to_add_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def list_availiable_virtual_nets_to_add_vpsa_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """list_availiable_virtual_nets_to_add_vpsa  # noqa: E501

        Returns the list of a available Virtual Networks to be added to 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_availiable_virtual_nets_to_add_vpsa_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20098
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/compatible_virtual_networks.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20098',  # 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_vpsas_comments(self, cloud_name, id, **kwargs):  # noqa: E501
        """list_vpsas_comments  # noqa: E501

        Returns the list of a VPSA's Comments.  # 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_vpsas_comments(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20020
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_vpsas_comments_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_vpsas_comments_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def list_vpsas_comments_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """list_vpsas_comments  # noqa: E501

        Returns the list of a VPSA's Comments.  # 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_vpsas_comments_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20020
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/comments.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20020',  # 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_vpsas_pools(self, cloud_name, id, **kwargs):  # noqa: E501
        """list_vpsas_pools  # noqa: E501

        Returns the list of a VPSA's Pools.  # 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_vpsas_pools(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20097
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_vpsas_pools_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_vpsas_pools_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def list_vpsas_pools_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """list_vpsas_pools  # noqa: E501

        Returns the list of a VPSA's Pools.  # 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_vpsas_pools_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20097
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/pools.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20097',  # 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_vpsas_vc(self, cloud_name, id, **kwargs):  # noqa: E501
        """list_vpsas_vc  # noqa: E501

        Returns the list of a VPSA's Virtual Controllers.  # 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_vpsas_vc(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20095
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_vpsas_vc_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_vpsas_vc_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def list_vpsas_vc_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """list_vpsas_vc  # noqa: E501

        Returns the list of a VPSA's Virtual Controllers.  # 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_vpsas_vc_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20095
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/virtual_controllers.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20095',  # 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_vpsas_virtual_nets(self, cloud_name, id, **kwargs):  # noqa: E501
        """list_vpsas_virtual_nets  # noqa: E501

        Returns the list of a Virtual Networks that belongs 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.list_vpsas_virtual_nets(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20099
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.list_vpsas_virtual_nets_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.list_vpsas_virtual_nets_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def list_vpsas_virtual_nets_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """list_vpsas_virtual_nets  # noqa: E501

        Returns the list of a Virtual Networks that belongs 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.list_vpsas_virtual_nets_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse20099
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/virtual_network_interfaces.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20099',  # 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 manage_vpsa_recycle_bin(self, cloud_name, id, enabled, **kwargs):  # noqa: E501
        """manage_vpsa_recycle_bin  # noqa: E501

        Enable/Disable volumes recycle bin for the given 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.manage_vpsa_recycle_bin(cloud_name, id, enabled, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param Enabled enabled: (required)
        :return: InlineResponse200117
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.manage_vpsa_recycle_bin_with_http_info(cloud_name, id, enabled, **kwargs)  # noqa: E501
        else:
            (data) = self.manage_vpsa_recycle_bin_with_http_info(cloud_name, id, enabled, **kwargs)  # noqa: E501
            return data

    def manage_vpsa_recycle_bin_with_http_info(self, cloud_name, id, enabled, **kwargs):  # noqa: E501
        """manage_vpsa_recycle_bin  # noqa: E501

        Enable/Disable volumes recycle bin for the given 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.manage_vpsa_recycle_bin_with_http_info(cloud_name, id, enabled, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param Enabled enabled: (required)
        :return: InlineResponse200117
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'enabled' in params:
            body_params = params['enabled']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/recycle_bin.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200117',  # 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 move_virtual_net_to_diff_sn(self, cloud_name, id, move_virtual_net_to_diff_sn, **kwargs):  # noqa: E501
        """move_virtual_net_to_diff_sn  # noqa: E501

        Move virtual controller to another storage node  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.move_virtual_net_to_diff_sn(cloud_name, id, move_virtual_net_to_diff_sn, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param MoveVirtualNetToDiffSn move_virtual_net_to_diff_sn: (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.move_virtual_net_to_diff_sn_with_http_info(cloud_name, id, move_virtual_net_to_diff_sn, **kwargs)  # noqa: E501
        else:
            (data) = self.move_virtual_net_to_diff_sn_with_http_info(cloud_name, id, move_virtual_net_to_diff_sn, **kwargs)  # noqa: E501
            return data

    def move_virtual_net_to_diff_sn_with_http_info(self, cloud_name, id, move_virtual_net_to_diff_sn, **kwargs):  # noqa: E501
        """move_virtual_net_to_diff_sn  # noqa: E501

        Move virtual controller to another storage node  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.move_virtual_net_to_diff_sn_with_http_info(cloud_name, id, move_virtual_net_to_diff_sn, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param MoveVirtualNetToDiffSn move_virtual_net_to_diff_sn: (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'move_virtual_net_to_diff_sn' in params:
            body_params = params['move_virtual_net_to_diff_sn']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/move_vc.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2004',  # 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 purge_vpsa_from_recycle_bin(self, cloud_name, id, **kwargs):  # noqa: E501
        """purge_vpsa_from_recycle_bin  # noqa: E501

        Purge VPSA from recycle_bin.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.purge_vpsa_from_recycle_bin(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200107
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.purge_vpsa_from_recycle_bin_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.purge_vpsa_from_recycle_bin_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def purge_vpsa_from_recycle_bin_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """purge_vpsa_from_recycle_bin  # noqa: E501

        Purge VPSA from recycle_bin.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.purge_vpsa_from_recycle_bin_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200107
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/purge.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200107',  # 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 release_networks_from_vpsa(self, cloud_name, id, **kwargs):  # noqa: E501
        """release_networks_from_vpsa  # noqa: E501

        Release networks from 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.release_networks_from_vpsa(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200109
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.release_networks_from_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.release_networks_from_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def release_networks_from_vpsa_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """release_networks_from_vpsa  # noqa: E501

        Release networks from 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.release_networks_from_vpsa_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200109
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/release_networks.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200109',  # 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_virtual_network_interface(self, cloud_name, id, remove_virtual_network_interface, **kwargs):  # noqa: E501
        """remove_virtual_network_interface  # noqa: E501

        Remove Virtual Network from 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_virtual_network_interface(cloud_name, id, remove_virtual_network_interface, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param RemoveVirtualNetworkInterface remove_virtual_network_interface: (required)
        :return: InlineResponse200111
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.remove_virtual_network_interface_with_http_info(cloud_name, id, remove_virtual_network_interface, **kwargs)  # noqa: E501
        else:
            (data) = self.remove_virtual_network_interface_with_http_info(cloud_name, id, remove_virtual_network_interface, **kwargs)  # noqa: E501
            return data

    def remove_virtual_network_interface_with_http_info(self, cloud_name, id, remove_virtual_network_interface, **kwargs):  # noqa: E501
        """remove_virtual_network_interface  # noqa: E501

        Remove Virtual Network from 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_virtual_network_interface_with_http_info(cloud_name, id, remove_virtual_network_interface, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param RemoveVirtualNetworkInterface remove_virtual_network_interface: (required)
        :return: InlineResponse200111
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/clouds/{cloud_name}/vpsas/{id}/remove_virtual_network_interface.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200111',  # 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 reschedule_upgrade_vpsa(self, cloud_name, id, reschedule_upgrade_vpsa, **kwargs):  # noqa: E501
        """reschedule_upgrade_vpsa  # noqa: E501

        Reschedule a pending VPSA upgrade/change model  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reschedule_upgrade_vpsa(cloud_name, id, reschedule_upgrade_vpsa, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' value as returned by get_all_vpsas. example '2653' (required)
        :param RescheduleUpgradeVpsa reschedule_upgrade_vpsa: (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.reschedule_upgrade_vpsa_with_http_info(cloud_name, id, reschedule_upgrade_vpsa, **kwargs)  # noqa: E501
        else:
            (data) = self.reschedule_upgrade_vpsa_with_http_info(cloud_name, id, reschedule_upgrade_vpsa, **kwargs)  # noqa: E501
            return data

    def reschedule_upgrade_vpsa_with_http_info(self, cloud_name, id, reschedule_upgrade_vpsa, **kwargs):  # noqa: E501
        """reschedule_upgrade_vpsa  # noqa: E501

        Reschedule a pending VPSA upgrade/change model  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reschedule_upgrade_vpsa_with_http_info(cloud_name, id, reschedule_upgrade_vpsa, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' value as returned by get_all_vpsas. example '2653' (required)
        :param RescheduleUpgradeVpsa reschedule_upgrade_vpsa: (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'reschedule_upgrade_vpsa' in params:
            body_params = params['reschedule_upgrade_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(
            '/clouds/{cloud_name}/vpsas/{id}/reschedule_upgrade.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2004',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

    def restore_vpsa(self, cloud_name, id, **kwargs):  # noqa: E501
        """restore_vpsa  # noqa: E501

        Restore VPSA from hibernation/recycle_bin.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_vpsa(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200106
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.restore_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.restore_vpsa_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def restore_vpsa_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """restore_vpsa  # noqa: E501

        Restore VPSA from hibernation/recycle_bin.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.restore_vpsa_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200106
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/restore.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200106',  # 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_upgrade(self, cloud_name, id, **kwargs):  # noqa: E501
        """resume_upgrade  # noqa: E501

        Resume a pending VPSA upgrade/change model  # 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_upgrade(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.resume_upgrade_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.resume_upgrade_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def resume_upgrade_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """resume_upgrade  # noqa: E501

        Resume a pending VPSA upgrade/change model  # 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_upgrade_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/resume_waiting.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2004',  # 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 unassign_public_ip(self, cloud_name, id, **kwargs):  # noqa: E501
        """unassign_public_ip  # noqa: E501

        Unassign public ip from 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.unassign_public_ip(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200104
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.unassign_public_ip_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.unassign_public_ip_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

    def unassign_public_ip_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """unassign_public_ip  # noqa: E501

        Unassign public ip from 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.unassign_public_ip_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :return: InlineResponse200104
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'id' in params:
            path_params['id'] = params['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(
            '/clouds/{cloud_name}/vpsas/{id}/public_ip/unassign.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200104',  # 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_cloud_vpsas_status(self, cloud_name, **kwargs):  # noqa: E501
        """update_cloud_vpsas_status  # noqa: E501

        Updates cloud vpsa's status.  # 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_cloud_vpsas_status(cloud_name, async_req=True)
        >>> result = thread.get()

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

    def update_cloud_vpsas_status_with_http_info(self, cloud_name, **kwargs):  # noqa: E501
        """update_cloud_vpsas_status  # noqa: E501

        Updates cloud vpsa's status.  # 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_cloud_vpsas_status_with_http_info(cloud_name, async_req=True)
        >>> result = thread.get()

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

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # 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(
            '/clouds/{cloud_name}/vpsas/update_vpsas_reporting.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200101',  # 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_vpsa_status(self, cloud_name, vpsa_name, **kwargs):  # noqa: E501
        """update_vpsa_status  # noqa: E501

        Updates single vpsa status.  # 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_vpsa_status(cloud_name, vpsa_name, async_req=True)
        >>> result = thread.get()

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

    def update_vpsa_status_with_http_info(self, cloud_name, vpsa_name, **kwargs):  # noqa: E501
        """update_vpsa_status  # noqa: E501

        Updates single vpsa status.  # 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_vpsa_status_with_http_info(cloud_name, vpsa_name, async_req=True)
        >>> result = thread.get()

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

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

        collection_formats = {}

        path_params = {}
        if 'cloud_name' in params:
            path_params['cloud_name'] = params['cloud_name']  # noqa: E501
        if 'vpsa_name' in params:
            path_params['vpsa_name'] = params['vpsa_name']  # 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(
            '/clouds/{cloud_name}/vpsas/{vpsa_name}/update_vpsa_reporting.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2004',  # 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_vpsa_upload_endpoint(self, cloud_name, id, update_vpsa_upload_endpoint, **kwargs):  # noqa: E501
        """update_vpsa_upload_endpoint  # noqa: E501

        Updates an existing vpsa upload endpoint  # 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_vpsa_upload_endpoint(cloud_name, id, update_vpsa_upload_endpoint, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param UpdateVpsaUploadEndpoint update_vpsa_upload_endpoint: (required)
        :return: InlineResponse200119
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.update_vpsa_upload_endpoint_with_http_info(cloud_name, id, update_vpsa_upload_endpoint, **kwargs)  # noqa: E501
        else:
            (data) = self.update_vpsa_upload_endpoint_with_http_info(cloud_name, id, update_vpsa_upload_endpoint, **kwargs)  # noqa: E501
            return data

    def update_vpsa_upload_endpoint_with_http_info(self, cloud_name, id, update_vpsa_upload_endpoint, **kwargs):  # noqa: E501
        """update_vpsa_upload_endpoint  # noqa: E501

        Updates an existing vpsa upload endpoint  # 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_vpsa_upload_endpoint_with_http_info(cloud_name, id, update_vpsa_upload_endpoint, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param UpdateVpsaUploadEndpoint update_vpsa_upload_endpoint: (required)
        :return: InlineResponse200119
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'update_vpsa_upload_endpoint' in params:
            body_params = params['update_vpsa_upload_endpoint']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/endpoints.json', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200119',  # 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 upgrade_vpsa_version(self, cloud_name, id, upgrade_vpsa_version, **kwargs):  # noqa: E501
        """upgrade_vpsa_version  # noqa: E501

        Upgrade a VPSA software to a specified image.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upgrade_vpsa_version(cloud_name, id, upgrade_vpsa_version, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param UpgradeVpsaVersion upgrade_vpsa_version: (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.upgrade_vpsa_version_with_http_info(cloud_name, id, upgrade_vpsa_version, **kwargs)  # noqa: E501
        else:
            (data) = self.upgrade_vpsa_version_with_http_info(cloud_name, id, upgrade_vpsa_version, **kwargs)  # noqa: E501
            return data

    def upgrade_vpsa_version_with_http_info(self, cloud_name, id, upgrade_vpsa_version, **kwargs):  # noqa: E501
        """upgrade_vpsa_version  # noqa: E501

        Upgrade a VPSA software to a specified image.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upgrade_vpsa_version_with_http_info(cloud_name, id, upgrade_vpsa_version, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param int id: The VPSA 'id' or 'internal-name' value as returned by get_all_vpsas. (required)
        :param UpgradeVpsaVersion upgrade_vpsa_version: (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'upgrade_vpsa_version' in params:
            body_params = params['upgrade_vpsa_version']
        # 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(
            '/clouds/{cloud_name}/vpsas/{id}/upgrade.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2004',  # 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)
