# 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 VPSAObjectStorageApi(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_to_zios(self, cloud_name, id, add_drives_to_zios, **kwargs):  # noqa: E501
        """add_drives_to_zios  # noqa: E501

        Add drives to VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_drives_to_zios(cloud_name, id, add_drives_to_zios, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param AddDrivesToZios add_drives_to_zios: (required)
        :return: InlineResponse200132
                 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_to_zios_with_http_info(cloud_name, id, add_drives_to_zios, **kwargs)  # noqa: E501
        else:
            (data) = self.add_drives_to_zios_with_http_info(cloud_name, id, add_drives_to_zios, **kwargs)  # noqa: E501
            return data

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

        Add drives to VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_drives_to_zios_with_http_info(cloud_name, id, add_drives_to_zios, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param AddDrivesToZios add_drives_to_zios: (required)
        :return: InlineResponse200132
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_name', 'id', 'add_drives_to_zios']  # 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_to_zios" % 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_to_zios`")  # 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_to_zios`")  # noqa: E501
        # verify the required parameter 'add_drives_to_zios' is set
        if self.api_client.client_side_validation and ('add_drives_to_zios' not in params or
                                                       params['add_drives_to_zios'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `add_drives_to_zios` when calling `add_drives_to_zios`")  # 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_to_zios' in params:
            body_params = params['add_drives_to_zios']
        # 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}/zioses/{id}/drives.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200132',  # 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_proxy_virtual_controller_zios(self, cloud_name, id, add_proxy_virtual_controller_zios, **kwargs):  # noqa: E501
        """add_proxy_virtual_controller_zios  # noqa: E501

        Add proxy virtual controller to VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_proxy_virtual_controller_zios(cloud_name, id, add_proxy_virtual_controller_zios, async_req=True)
        >>> result = thread.get()

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

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

        Add proxy virtual controller to VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_proxy_virtual_controller_zios_with_http_info(cloud_name, id, add_proxy_virtual_controller_zios, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param AddProxyVirtualControllerZios add_proxy_virtual_controller_zios: (required)
        :return: InlineResponse200142
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method add_proxy_virtual_controller_zios" % 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_proxy_virtual_controller_zios`")  # 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_proxy_virtual_controller_zios`")  # noqa: E501
        # verify the required parameter 'add_proxy_virtual_controller_zios' is set
        if self.api_client.client_side_validation and ('add_proxy_virtual_controller_zios' not in params or
                                                       params['add_proxy_virtual_controller_zios'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `add_proxy_virtual_controller_zios` when calling `add_proxy_virtual_controller_zios`")  # 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_proxy_virtual_controller_zios' in params:
            body_params = params['add_proxy_virtual_controller_zios']
        # 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}/zioses/{id}/proxy_vcs.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200142',  # 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_nets_to_zios(self, cloud_name, id, add_virtual_nets_to_zios, **kwargs):  # noqa: E501
        """add_virtual_nets_to_zios  # noqa: E501

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

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param AddVirtualNetsToZios add_virtual_nets_to_zios: (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_nets_to_zios_with_http_info(cloud_name, id, add_virtual_nets_to_zios, **kwargs)  # noqa: E501
        else:
            (data) = self.add_virtual_nets_to_zios_with_http_info(cloud_name, id, add_virtual_nets_to_zios, **kwargs)  # noqa: E501
            return data

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

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

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

        all_params = ['cloud_name', 'id', 'add_virtual_nets_to_zios']  # 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_nets_to_zios" % 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_nets_to_zios`")  # 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_nets_to_zios`")  # noqa: E501
        # verify the required parameter 'add_virtual_nets_to_zios' is set
        if self.api_client.client_side_validation and ('add_virtual_nets_to_zios' not in params or
                                                       params['add_virtual_nets_to_zios'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `add_virtual_nets_to_zios` when calling `add_virtual_nets_to_zios`")  # 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_nets_to_zios' in params:
            body_params = params['add_virtual_nets_to_zios']
        # 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}/zioses/{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_zios_endpoints_configs_for_upload_types(self, cloud_name, id, add_zios_endpoints_configs_for_upload_types, **kwargs):  # noqa: E501
        """add_zios_endpoints_configs_for_upload_types  # noqa: E501

        Adds more VPSA Object Storage 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_zios_endpoints_configs_for_upload_types(cloud_name, id, add_zios_endpoints_configs_for_upload_types, async_req=True)
        >>> result = thread.get()

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

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

        Adds more VPSA Object Storage 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_zios_endpoints_configs_for_upload_types_with_http_info(cloud_name, id, add_zios_endpoints_configs_for_upload_types, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param AddZiosEndpointsConfigsForUploadTypes add_zios_endpoints_configs_for_upload_types: (required)
        :return: InlineResponse200150
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_name', 'id', 'add_zios_endpoints_configs_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_zios_endpoints_configs_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_zios_endpoints_configs_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_zios_endpoints_configs_for_upload_types`")  # noqa: E501
        # verify the required parameter 'add_zios_endpoints_configs_for_upload_types' is set
        if self.api_client.client_side_validation and ('add_zios_endpoints_configs_for_upload_types' not in params or
                                                       params['add_zios_endpoints_configs_for_upload_types'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `add_zios_endpoints_configs_for_upload_types` when calling `add_zios_endpoints_configs_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_zios_endpoints_configs_for_upload_types' in params:
            body_params = params['add_zios_endpoints_configs_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}/zioses/{id}/endpoints_config.json', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200150',  # 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_zios(self, cloud_name, id, assign_public_ip_zios, **kwargs):  # noqa: E501
        """assign_public_ip_zios  # noqa: E501

        Assign public ip to VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.assign_public_ip_zios(cloud_name, id, assign_public_ip_zios, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param AssignPublicIpZios assign_public_ip_zios: (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_zios_with_http_info(cloud_name, id, assign_public_ip_zios, **kwargs)  # noqa: E501
        else:
            (data) = self.assign_public_ip_zios_with_http_info(cloud_name, id, assign_public_ip_zios, **kwargs)  # noqa: E501
            return data

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

        Assign public ip to VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.assign_public_ip_zios_with_http_info(cloud_name, id, assign_public_ip_zios, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param AssignPublicIpZios assign_public_ip_zios: (required)
        :return: InlineResponse200103
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_name', 'id', 'assign_public_ip_zios']  # 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_zios" % 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_zios`")  # 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_zios`")  # noqa: E501
        # verify the required parameter 'assign_public_ip_zios' is set
        if self.api_client.client_side_validation and ('assign_public_ip_zios' not in params or
                                                       params['assign_public_ip_zios'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `assign_public_ip_zios` when calling `assign_public_ip_zios`")  # 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_zios' in params:
            body_params = params['assign_public_ip_zios']
        # 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}/zioses/{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 change_engine_type_zios(self, cloud_name, id, change_engine_type_zios, **kwargs):  # noqa: E501
        """change_engine_type_zios  # noqa: E501

        Changes VPSA Object Storage engine from ZIOS_MINI to VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.change_engine_type_zios(cloud_name, id, change_engine_type_zios, async_req=True)
        >>> result = thread.get()

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

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

        Changes VPSA Object Storage engine from ZIOS_MINI to VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.change_engine_type_zios_with_http_info(cloud_name, id, change_engine_type_zios, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param ChangeEngineTypeZios change_engine_type_zios: (required)
        :return: InlineResponse200102
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_name', 'id', 'change_engine_type_zios']  # 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_engine_type_zios" % 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_engine_type_zios`")  # 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_engine_type_zios`")  # noqa: E501
        # verify the required parameter 'change_engine_type_zios' is set
        if self.api_client.client_side_validation and ('change_engine_type_zios' not in params or
                                                       params['change_engine_type_zios'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `change_engine_type_zios` when calling `change_engine_type_zios`")  # 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_engine_type_zios' in params:
            body_params = params['change_engine_type_zios']
        # 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_engine_type.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200102',  # 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 continue_policy_rebalance_zios(self, cloud_name, id, continue_policy_rebalance_zios, **kwargs):  # noqa: E501
        """continue_policy_rebalance_zios  # noqa: E501

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

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

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

        Continue a storage policy rebalance.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.continue_policy_rebalance_zios_with_http_info(cloud_name, id, continue_policy_rebalance_zios, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param ContinuePolicyRebalanceZios continue_policy_rebalance_zios: (required)
        :return: InlineResponse200144
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_name', 'id', 'continue_policy_rebalance_zios']  # 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 continue_policy_rebalance_zios" % 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 `continue_policy_rebalance_zios`")  # 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 `continue_policy_rebalance_zios`")  # noqa: E501
        # verify the required parameter 'continue_policy_rebalance_zios' is set
        if self.api_client.client_side_validation and ('continue_policy_rebalance_zios' not in params or
                                                       params['continue_policy_rebalance_zios'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `continue_policy_rebalance_zios` when calling `continue_policy_rebalance_zios`")  # 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 'continue_policy_rebalance_zios' in params:
            body_params = params['continue_policy_rebalance_zios']
        # 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}/zioses/{id}/policy_continue_rebalance.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200144',  # 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_storage_policy_zios(self, cloud_name, id, create_storage_policy_zios, **kwargs):  # noqa: E501
        """create_storage_policy_zios  # noqa: E501

        Creates a new policy to VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_storage_policy_zios(cloud_name, id, create_storage_policy_zios, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: The cloud 'name' as returned by get_all_clouds (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param CreateStoragePolicyZios create_storage_policy_zios: (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_storage_policy_zios_with_http_info(cloud_name, id, create_storage_policy_zios, **kwargs)  # noqa: E501
        else:
            (data) = self.create_storage_policy_zios_with_http_info(cloud_name, id, create_storage_policy_zios, **kwargs)  # noqa: E501
            return data

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

        Creates a new policy to VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.create_storage_policy_zios_with_http_info(cloud_name, id, create_storage_policy_zios, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: The cloud 'name' as returned by get_all_clouds (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param CreateStoragePolicyZios create_storage_policy_zios: (required)
        :return: InlineResponse2004
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_name', 'id', 'create_storage_policy_zios']  # 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_storage_policy_zios" % 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_storage_policy_zios`")  # 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_storage_policy_zios`")  # noqa: E501
        # verify the required parameter 'create_storage_policy_zios' is set
        if self.api_client.client_side_validation and ('create_storage_policy_zios' not in params or
                                                       params['create_storage_policy_zios'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `create_storage_policy_zios` when calling `create_storage_policy_zios`")  # 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_storage_policy_zios' in params:
            body_params = params['create_storage_policy_zios']
        # 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}/zioses/{id}/policy.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 create_zios_endpoints_configs_for_upload_types(self, cloud_name, id, create_zios_endpoints_configs_for_upload_types, **kwargs):  # noqa: E501
        """create_zios_endpoints_configs_for_upload_types  # noqa: E501

        Creates VPSA Object Storage 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_zios_endpoints_configs_for_upload_types(cloud_name, id, create_zios_endpoints_configs_for_upload_types, async_req=True)
        >>> result = thread.get()

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

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

        Creates VPSA Object Storage 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_zios_endpoints_configs_for_upload_types_with_http_info(cloud_name, id, create_zios_endpoints_configs_for_upload_types, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param CreateZiosEndpointsConfigsForUploadTypes create_zios_endpoints_configs_for_upload_types: (required)
        :return: InlineResponse200151
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_name', 'id', 'create_zios_endpoints_configs_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_zios_endpoints_configs_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_zios_endpoints_configs_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_zios_endpoints_configs_for_upload_types`")  # noqa: E501
        # verify the required parameter 'create_zios_endpoints_configs_for_upload_types' is set
        if self.api_client.client_side_validation and ('create_zios_endpoints_configs_for_upload_types' not in params or
                                                       params['create_zios_endpoints_configs_for_upload_types'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `create_zios_endpoints_configs_for_upload_types` when calling `create_zios_endpoints_configs_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_zios_endpoints_configs_for_upload_types' in params:
            body_params = params['create_zios_endpoints_configs_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}/zioses/{id}/endpoints_config.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200151',  # 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_zios_upload_endpoint(self, cloud_name, id, create_zios_upload_endpoint, **kwargs):  # noqa: E501
        """create_zios_upload_endpoint  # noqa: E501

        Creates a new VPSA Object Storage 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_zios_upload_endpoint(cloud_name, id, create_zios_upload_endpoint, async_req=True)
        >>> result = thread.get()

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

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

        Creates a new VPSA Object Storage 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_zios_upload_endpoint_with_http_info(cloud_name, id, create_zios_upload_endpoint, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param CreateZiosUploadEndpoint create_zios_upload_endpoint: (required)
        :return: InlineResponse200147
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_name', 'id', 'create_zios_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_zios_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_zios_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_zios_upload_endpoint`")  # noqa: E501
        # verify the required parameter 'create_zios_upload_endpoint' is set
        if self.api_client.client_side_validation and ('create_zios_upload_endpoint' not in params or
                                                       params['create_zios_upload_endpoint'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `create_zios_upload_endpoint` when calling `create_zios_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_zios_upload_endpoint' in params:
            body_params = params['create_zios_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}/zioses/{id}/endpoints.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200147',  # 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_zios(self, cloud_name, id, create_zsnap_zios, **kwargs):  # noqa: E501
        """create_zsnap_zios  # noqa: E501

        Create a VPSA Object Storage 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_zios(cloud_name, id, create_zsnap_zios, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param CreateZsnapZios create_zsnap_zios: (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_zios_with_http_info(cloud_name, id, create_zsnap_zios, **kwargs)  # noqa: E501
        else:
            (data) = self.create_zsnap_zios_with_http_info(cloud_name, id, create_zsnap_zios, **kwargs)  # noqa: E501
            return data

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

        Create a VPSA Object Storage 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_zios_with_http_info(cloud_name, id, create_zsnap_zios, async_req=True)
        >>> result = thread.get()

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

        all_params = ['cloud_name', 'id', 'create_zsnap_zios']  # 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_zios" % 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_zios`")  # 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_zios`")  # noqa: E501
        # verify the required parameter 'create_zsnap_zios' is set
        if self.api_client.client_side_validation and ('create_zsnap_zios' not in params or
                                                       params['create_zsnap_zios'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `create_zsnap_zios` when calling `create_zsnap_zios`")  # 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_zios' in params:
            body_params = params['create_zsnap_zios']
        # 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}/zioses/{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_zios_endpoints_config_for_upload_types(self, cloud_name, id, delete_zios_endpoints_config_for_upload_types, **kwargs):  # noqa: E501
        """delete_zios_endpoints_config_for_upload_types  # noqa: E501

        Deletes an existing VPSA Object Storage 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_zios_endpoints_config_for_upload_types(cloud_name, id, delete_zios_endpoints_config_for_upload_types, async_req=True)
        >>> result = thread.get()

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

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

        Deletes an existing VPSA Object Storage 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_zios_endpoints_config_for_upload_types_with_http_info(cloud_name, id, delete_zios_endpoints_config_for_upload_types, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param DeleteZiosEndpointsConfigForUploadTypes delete_zios_endpoints_config_for_upload_types: (required)
        :return: InlineResponse200152
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_name', 'id', 'delete_zios_endpoints_config_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_zios_endpoints_config_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_zios_endpoints_config_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_zios_endpoints_config_for_upload_types`")  # noqa: E501
        # verify the required parameter 'delete_zios_endpoints_config_for_upload_types' is set
        if self.api_client.client_side_validation and ('delete_zios_endpoints_config_for_upload_types' not in params or
                                                       params['delete_zios_endpoints_config_for_upload_types'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `delete_zios_endpoints_config_for_upload_types` when calling `delete_zios_endpoints_config_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_zios_endpoints_config_for_upload_types' in params:
            body_params = params['delete_zios_endpoints_config_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}/zioses/{id}/endpoints_config.json', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200152',  # 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_zios_upload_endpoint(self, cloud_name, id, delete_zios_upload_endpoint, **kwargs):  # noqa: E501
        """delete_zios_upload_endpoint  # noqa: E501

        Deletes an existing VPSA Object Storage 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_zios_upload_endpoint(cloud_name, id, delete_zios_upload_endpoint, async_req=True)
        >>> result = thread.get()

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

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

        Deletes an existing VPSA Object Storage 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_zios_upload_endpoint_with_http_info(cloud_name, id, delete_zios_upload_endpoint, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param DeleteZiosUploadEndpoint delete_zios_upload_endpoint: (required)
        :return: InlineResponse200148
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_name', 'id', 'delete_zios_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_zios_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_zios_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_zios_upload_endpoint`")  # noqa: E501
        # verify the required parameter 'delete_zios_upload_endpoint' is set
        if self.api_client.client_side_validation and ('delete_zios_upload_endpoint' not in params or
                                                       params['delete_zios_upload_endpoint'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `delete_zios_upload_endpoint` when calling `delete_zios_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_zios_upload_endpoint' in params:
            body_params = params['delete_zios_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}/zioses/{id}/endpoints.json', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200148',  # 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_elastic_load_balancer_zios(self, cloud_name, id, **kwargs):  # noqa: E501
        """disable_elastic_load_balancer_zios  # noqa: E501

        Disable Elastic Load Balancer in VPSA Object Storage..  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_elastic_load_balancer_zios(cloud_name, id, async_req=True)
        >>> result = thread.get()

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

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

        Disable Elastic Load Balancer in VPSA Object Storage..  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_elastic_load_balancer_zios_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :return: InlineResponse200102
                 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_elastic_load_balancer_zios" % 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_elastic_load_balancer_zios`")  # 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_elastic_load_balancer_zios`")  # 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}/zioses/{id}/disable_external_load_balancer.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200102',  # 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_elastic_load_balancer_zios(self, cloud_name, id, **kwargs):  # noqa: E501
        """enable_elastic_load_balancer_zios  # noqa: E501

        Enable Elastic Load Balancer in VPSA Object Storage..  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_elastic_load_balancer_zios(cloud_name, id, async_req=True)
        >>> result = thread.get()

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

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

        Enable Elastic Load Balancer in VPSA Object Storage..  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_elastic_load_balancer_zios_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :return: InlineResponse200102
                 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_elastic_load_balancer_zios" % 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_elastic_load_balancer_zios`")  # 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_elastic_load_balancer_zios`")  # 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}/zioses/{id}/enable_external_load_balancer.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200102',  # 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_vpsaos(self, cloud_name, **kwargs):  # noqa: E501
        """get_all_vpsaos  # noqa: E501

        Returns a list of all VPSA Object Storage Object stores.  # 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_vpsaos(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: InlineResponse200129
                 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_vpsaos_with_http_info(cloud_name, **kwargs)  # noqa: E501
        else:
            (data) = self.get_all_vpsaos_with_http_info(cloud_name, **kwargs)  # noqa: E501
            return data

    def get_all_vpsaos_with_http_info(self, cloud_name, **kwargs):  # noqa: E501
        """get_all_vpsaos  # noqa: E501

        Returns a list of all VPSA Object Storage Object stores.  # 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_vpsaos_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: InlineResponse200129
                 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_vpsaos" % 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_vpsaos`")  # 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}/zioses.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200129',  # 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_zios_drives_from_cc(self, cloud_name, id, **kwargs):  # noqa: E501
        """get_all_zios_drives_from_cc  # noqa: E501

        Returns the list of a VPSA Object Storage 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_zios_drives_from_cc(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :return: InlineResponse200131
                 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_zios_drives_from_cc_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_all_zios_drives_from_cc_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

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

        Returns the list of a VPSA Object Storage 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_zios_drives_from_cc_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :return: InlineResponse200131
                 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_zios_drives_from_cc" % 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_zios_drives_from_cc`")  # 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_zios_drives_from_cc`")  # 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}/zioses/{id}/drives.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200131',  # 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_load_balancer(self, cloud_name, id, **kwargs):  # noqa: E501
        """get_load_balancer  # noqa: E501

        Returns the list of a VPSA Object Storage load balancers.  # 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_load_balancer(cloud_name, id, async_req=True)
        >>> result = thread.get()

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

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

        Returns the list of a VPSA Object Storage load balancers.  # 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_load_balancer_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :return: InlineResponse200135
                 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_load_balancer" % 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_load_balancer`")  # 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_load_balancer`")  # 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}/zioses/{id}/load_balancer.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200135',  # 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_vpsaos_accounts(self, cloud_name, id, **kwargs):  # noqa: E501
        """get_vpsaos_accounts  # noqa: E501

        Returns the list of a VPSA Object Storage accounts.  # 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_vpsaos_accounts(cloud_name, id, async_req=True)
        >>> result = thread.get()

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

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

        Returns the list of a VPSA Object Storage accounts.  # 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_vpsaos_accounts_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :return: InlineResponse200136
                 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_vpsaos_accounts" % 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_vpsaos_accounts`")  # 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_vpsaos_accounts`")  # 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}/zioses/{id}/accounts.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200136',  # 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_vpsaos_comments(self, cloud_name, id, **kwargs):  # noqa: E501
        """get_vpsaos_comments  # noqa: E501

        Returns the list of a ZIOSes 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.get_vpsaos_comments(cloud_name, id, async_req=True)
        >>> result = thread.get()

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

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

        Returns the list of a ZIOSes 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.get_vpsaos_comments_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (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 get_vpsaos_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 `get_vpsaos_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 `get_vpsaos_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}/zioses/{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 get_vpsaos_sps(self, cloud_name, id, **kwargs):  # noqa: E501
        """get_vpsaos_sps  # noqa: E501

        Returns the list of a VPSA Object Storage storage policies.  # 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_vpsaos_sps(cloud_name, id, async_req=True)
        >>> result = thread.get()

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

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

        Returns the list of a VPSA Object Storage storage policies.  # 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_vpsaos_sps_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :return: InlineResponse200134
                 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_vpsaos_sps" % 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_vpsaos_sps`")  # 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_vpsaos_sps`")  # 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}/zioses/{id}/storage_policies.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200134',  # 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_vpsaos_vcs(self, cloud_name, id, **kwargs):  # noqa: E501
        """get_vpsaos_vcs  # noqa: E501

        Returns the list of a VPSA Object Storage 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.get_vpsaos_vcs(cloud_name, id, async_req=True)
        >>> result = thread.get()

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

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

        Returns the list of a VPSA Object Storage 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.get_vpsaos_vcs_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :return: InlineResponse200133
                 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_vpsaos_vcs" % 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_vpsaos_vcs`")  # 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_vpsaos_vcs`")  # 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}/zioses/{id}/virtual_controllers.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200133',  # 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_zios_from_cloud(self, cloud_name, id, **kwargs):  # noqa: E501
        """get_zios_from_cloud  # noqa: E501

        Returns the details for a single VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_zios_from_cloud(cloud_name, id, async_req=True)
        >>> result = thread.get()

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

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

        Returns the details for a single VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_zios_from_cloud_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :return: InlineResponse200130
                 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_zios_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_zios_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_zios_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}/zioses/{id}.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200130',  # 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_zios_upload_endpoints(self, cloud_name, id, get_zios_upload_endpoints, **kwargs):  # noqa: E501
        """get_zios_upload_endpoints  # noqa: E501

        Gets all VPSA Object Storage 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.get_zios_upload_endpoints(cloud_name, id, get_zios_upload_endpoints, async_req=True)
        >>> result = thread.get()

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

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

        Gets all VPSA Object Storage 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.get_zios_upload_endpoints_with_http_info(cloud_name, id, get_zios_upload_endpoints, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param GetZiosUploadEndpoints get_zios_upload_endpoints: (required)
        :return: InlineResponse200145
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_name', 'id', 'get_zios_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 get_zios_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 `get_zios_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 `get_zios_upload_endpoints`")  # noqa: E501
        # verify the required parameter 'get_zios_upload_endpoints' is set
        if self.api_client.client_side_validation and ('get_zios_upload_endpoints' not in params or
                                                       params['get_zios_upload_endpoints'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `get_zios_upload_endpoints` when calling `get_zios_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 'get_zios_upload_endpoints' in params:
            body_params = params['get_zios_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}/zioses/{id}/endpoints.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200145',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

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

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

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

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

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :return: InlineResponse200139
                 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 hibernate_zios" % 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 `hibernate_zios`")  # 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 `hibernate_zios`")  # 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}/zioses/{id}/hibernate.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200139',  # 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_availiables_virtual_net_to_add_vpsa(self, cloud_name, id, **kwargs):  # noqa: E501
        """list_availiables_virtual_net_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_availiables_virtual_net_to_add_vpsa(cloud_name, id, async_req=True)
        >>> result = thread.get()

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

    def list_availiables_virtual_net_to_add_vpsa_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """list_availiables_virtual_net_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_availiables_virtual_net_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 str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (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_availiables_virtual_net_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_availiables_virtual_net_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_availiables_virtual_net_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}/zioses/{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_vpsa_virtual_nets(self, cloud_name, id, **kwargs):  # noqa: E501
        """list_vpsa_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_vpsa_virtual_nets(cloud_name, id, async_req=True)
        >>> result = thread.get()

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

    def list_vpsa_virtual_nets_with_http_info(self, cloud_name, id, **kwargs):  # noqa: E501
        """list_vpsa_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_vpsa_virtual_nets_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :return: InlineResponse200137
                 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_vpsa_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_vpsa_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_vpsa_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}/zioses/{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='InlineResponse200137',  # 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_zios_endpoints_configs_by_upload_types(self, cloud_name, id, list_zios_endpoints_configs_by_upload_types, **kwargs):  # noqa: E501
        """list_zios_endpoints_configs_by_upload_types  # noqa: E501

        Gets VPSA Object Storage 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.list_zios_endpoints_configs_by_upload_types(cloud_name, id, list_zios_endpoints_configs_by_upload_types, async_req=True)
        >>> result = thread.get()

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

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

        Gets VPSA Object Storage 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.list_zios_endpoints_configs_by_upload_types_with_http_info(cloud_name, id, list_zios_endpoints_configs_by_upload_types, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param ListZiosEndpointsConfigsByUploadTypes list_zios_endpoints_configs_by_upload_types: (required)
        :return: InlineResponse200149
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_name', 'id', 'list_zios_endpoints_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 list_zios_endpoints_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 `list_zios_endpoints_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 `list_zios_endpoints_configs_by_upload_types`")  # noqa: E501
        # verify the required parameter 'list_zios_endpoints_configs_by_upload_types' is set
        if self.api_client.client_side_validation and ('list_zios_endpoints_configs_by_upload_types' not in params or
                                                       params['list_zios_endpoints_configs_by_upload_types'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `list_zios_endpoints_configs_by_upload_types` when calling `list_zios_endpoints_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 'list_zios_endpoints_configs_by_upload_types' in params:
            body_params = params['list_zios_endpoints_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}/zioses/{id}/endpoints_config.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200149',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Enter or exit maintenance mode for VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.maintenance_mode(cloud_name, id, maintenance_mode, async_req=True)
        >>> result = thread.get()

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

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

        Enter or exit maintenance mode for VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.maintenance_mode_with_http_info(cloud_name, id, maintenance_mode, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param MaintenanceMode maintenance_mode: (required)
        :return: InlineResponse200141
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        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 'maintenance_mode' in params:
            body_params = params['maintenance_mode']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

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

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

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

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

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

        Pause a storage policy rebalance.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.pause_policy_rebalance_zios_with_http_info(cloud_name, id, pause_policy_rebalance_zios, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param PausePolicyRebalanceZios pause_policy_rebalance_zios: (required)
        :return: InlineResponse200143
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_name', 'id', 'pause_policy_rebalance_zios']  # 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 pause_policy_rebalance_zios" % 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 `pause_policy_rebalance_zios`")  # 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 `pause_policy_rebalance_zios`")  # noqa: E501
        # verify the required parameter 'pause_policy_rebalance_zios' is set
        if self.api_client.client_side_validation and ('pause_policy_rebalance_zios' not in params or
                                                       params['pause_policy_rebalance_zios'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `pause_policy_rebalance_zios` when calling `pause_policy_rebalance_zios`")  # 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 'pause_policy_rebalance_zios' in params:
            body_params = params['pause_policy_rebalance_zios']
        # 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}/zioses/{id}/policy_pause_rebalance.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200143',  # 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_nets_from_zios(self, cloud_name, id, remove_virtual_nets_from_zios, **kwargs):  # noqa: E501
        """remove_virtual_nets_from_zios  # noqa: E501

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

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param RemoveVirtualNetsFromZios remove_virtual_nets_from_zios: (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.remove_virtual_nets_from_zios_with_http_info(cloud_name, id, remove_virtual_nets_from_zios, **kwargs)  # noqa: E501
        else:
            (data) = self.remove_virtual_nets_from_zios_with_http_info(cloud_name, id, remove_virtual_nets_from_zios, **kwargs)  # noqa: E501
            return data

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

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

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

        all_params = ['cloud_name', 'id', 'remove_virtual_nets_from_zios']  # 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_nets_from_zios" % 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_nets_from_zios`")  # 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_nets_from_zios`")  # noqa: E501
        # verify the required parameter 'remove_virtual_nets_from_zios' is set
        if self.api_client.client_side_validation and ('remove_virtual_nets_from_zios' not in params or
                                                       params['remove_virtual_nets_from_zios'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `remove_virtual_nets_from_zios` when calling `remove_virtual_nets_from_zios`")  # 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_nets_from_zios' in params:
            body_params = params['remove_virtual_nets_from_zios']
        # 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}/zioses/{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='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_zios(self, cloud_name, id, **kwargs):  # noqa: E501
        """restore_zios  # noqa: E501

        Restore VPSA Object Storage from hibernation.  # 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_zios(cloud_name, id, async_req=True)
        >>> result = thread.get()

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

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

        Restore VPSA Object Storage from hibernation.  # 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_zios_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :return: InlineResponse200140
                 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_zios" % 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_zios`")  # 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_zios`")  # 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}/zioses/{id}/restore.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200140',  # 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_zios(self, cloud_name, id, **kwargs):  # noqa: E501
        """unassign_public_ip_zios  # noqa: E501

        Unassign public ip from VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unassign_public_ip_zios(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :return: InlineResponse200138
                 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_zios_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
        else:
            (data) = self.unassign_public_ip_zios_with_http_info(cloud_name, id, **kwargs)  # noqa: E501
            return data

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

        Unassign public ip from VPSA Object Storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unassign_public_ip_zios_with_http_info(cloud_name, id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :return: InlineResponse200138
                 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_zios" % 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_zios`")  # 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_zios`")  # 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}/zioses/{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='InlineResponse200138',  # 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_zios_upload_endpoint(self, cloud_name, id, update_zios_upload_endpoint, **kwargs):  # noqa: E501
        """update_zios_upload_endpoint  # noqa: E501

        Updates an existing VPSA Object Storage 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_zios_upload_endpoint(cloud_name, id, update_zios_upload_endpoint, async_req=True)
        >>> result = thread.get()

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

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

        Updates an existing VPSA Object Storage 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_zios_upload_endpoint_with_http_info(cloud_name, id, update_zios_upload_endpoint, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param UpdateZiosUploadEndpoint update_zios_upload_endpoint: (required)
        :return: InlineResponse200146
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_name', 'id', 'update_zios_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_zios_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_zios_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_zios_upload_endpoint`")  # noqa: E501
        # verify the required parameter 'update_zios_upload_endpoint' is set
        if self.api_client.client_side_validation and ('update_zios_upload_endpoint' not in params or
                                                       params['update_zios_upload_endpoint'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `update_zios_upload_endpoint` when calling `update_zios_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_zios_upload_endpoint' in params:
            body_params = params['update_zios_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}/zioses/{id}/endpoints.json', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200146',  # 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_zios(self, cloud_name, id, upgrade_zios, **kwargs):  # noqa: E501
        """upgrade_zios  # noqa: E501

        Upgrade a VPSA Object Storage 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_zios(cloud_name, id, upgrade_zios, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str cloud_name: (required)
        :param str id: The VPSA Object Storage 'id' or 'internal-name' value as returned by get_all_zioses. (required)
        :param UpgradeZios upgrade_zios: (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_zios_with_http_info(cloud_name, id, upgrade_zios, **kwargs)  # noqa: E501
        else:
            (data) = self.upgrade_zios_with_http_info(cloud_name, id, upgrade_zios, **kwargs)  # noqa: E501
            return data

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

        Upgrade a VPSA Object Storage 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_zios_with_http_info(cloud_name, id, upgrade_zios, async_req=True)
        >>> result = thread.get()

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

        all_params = ['cloud_name', 'id', 'upgrade_zios']  # 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_zios" % 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_zios`")  # 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_zios`")  # noqa: E501
        # verify the required parameter 'upgrade_zios' is set
        if self.api_client.client_side_validation and ('upgrade_zios' not in params or
                                                       params['upgrade_zios'] is None):  # noqa: E501
            raise ValueError("Missing the required parameter `upgrade_zios` when calling `upgrade_zios`")  # 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_zios' in params:
            body_params = params['upgrade_zios']
        # 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}/zioses/{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)
