# coding: utf-8

"""
    Zadara VPSA Storage Array REST API

     # Overview  This document outlines the methods available for administrating your Zadara Storage VPSA&#8482;. The Zadara Storage Array REST API   supports form-encoded, JSON, and XML requests, and can return either JSON or XML responses.  ## Usage  The majority of the APIs available require authentication which requires an API token to use. You can retrieve this token through the   Users section of your VPSA, or through the API using the \"Return a user's access key\" API in the Users Section below.  ## Authentication Methods  The authentication token can be passed either through the access_key parameter inside of the body of the REST API request, or   through the X-Access-Key header.  ## Timeouts  By default, all operations that don't complete within five seconds will return a message informing you that the action may take some  time to complete. When using the API, this can cause some actions, such as large volume creation, to be undesirably asynchronous.  You can specify your own timeout with the timeout parameter, in seconds, and a timeout value of -1 specifies an infinite timeout.  ## Specific Fields For Product  Some of the fields/actions used in the API should be used only for a specific product. The following tags are used to mark which   product responds to the fields/actions  VPSA Flash Array  VPSA Storage Array - Hybrid VPSA  ## Questions  If you have any questions or need support involving the REST API, please contact for assistance.   # noqa: E501

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


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from Vpsa.api_client import ApiClient


class PoolsApi(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 cancel_shrink_pool(self, id, **kwargs):  # noqa: E501
        """cancel_shrink_pool  # noqa: E501

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

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

    def cancel_shrink_pool_with_http_info(self, id, **kwargs):  # noqa: E501
        """cancel_shrink_pool  # noqa: E501

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

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

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

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `cancel_shrink_pool`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        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(
            '/pools/{id}/cancel_shrink.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20075',  # 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_pool(self, create_pool, **kwargs):  # noqa: E501
        """create_pool  # noqa: E501

        Create a Pool.  # 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_pool(create_pool, async_req=True)
        >>> result = thread.get()

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

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

        Create a Pool.  # 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_pool_with_http_info(create_pool, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreatePool create_pool: (required)
        :return: InlineResponse20067
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_pool' in params:
            body_params = params['create_pool']
        # 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(
            '/pools.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20067',  # 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_pool(self, id, **kwargs):  # noqa: E501
        """delete_pool  # noqa: E501

        Delete a Pool. The Pool must be empty.  # 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_pool(id, async_req=True)
        >>> result = thread.get()

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

    def delete_pool_with_http_info(self, id, **kwargs):  # noqa: E501
        """delete_pool  # noqa: E501

        Delete a Pool. The Pool must be empty.  # 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_pool_with_http_info(id, async_req=True)
        >>> result = thread.get()

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

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

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_pool" % key
                )
            params[key] = val
        del params['kwargs']
        # 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_pool`")  # noqa: E501

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `delete_pool`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        collection_formats = {}

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

        Add additional RAID Groups Or OBS Tier to a Pool.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.expand_pool(id, expand_pool, async_req=True)
        >>> result = thread.get()

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

    def expand_pool_with_http_info(self, id, expand_pool, **kwargs):  # noqa: E501
        """expand_pool  # noqa: E501

        Add additional RAID Groups Or OBS Tier to a Pool.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.expand_pool_with_http_info(id, expand_pool, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param ExpandPool expand_pool: (required)
        :return: InlineResponse20073
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `expand_pool`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'expand_pool' in params:
            body_params = params['expand_pool']
        # 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(
            '/pools/{id}/expand.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20073',  # 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_pools(self, **kwargs):  # noqa: E501
        """get_all_pools  # noqa: E501

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

        :param async_req bool
        :param int start: The item number to start from. 0 starts from the beginning.
        :param int limit: The total number of records to return.
        :return: InlineResponse20066
                 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_pools_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.get_all_pools_with_http_info(**kwargs)  # noqa: E501
            return data

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

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

        :param async_req bool
        :param int start: The item number to start from. 0 starts from the beginning.
        :param int limit: The total number of records to return.
        :return: InlineResponse20066
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        if self.api_client.client_side_validation and ('start' in params and params['start'] < 0):  # noqa: E501
            raise ValueError("Invalid value for parameter `start` when calling `get_all_pools`, must be a value greater than or equal to `0`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501
        if 'limit' in params:
            query_params.append(('limit', params['limit']))  # 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(
            '/pools.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20066',  # 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_pool(self, id, **kwargs):  # noqa: E501
        """get_pool  # noqa: E501

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

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

    def get_pool_with_http_info(self, id, **kwargs):  # noqa: E501
        """get_pool  # noqa: E501

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

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

        all_params = ['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_pool" % key
                )
            params[key] = val
        del params['kwargs']
        # 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_pool`")  # noqa: E501

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `get_pool`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        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(
            '/pools/{id}.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20068',  # 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_pool_destination_volume_data(self, id, volname, **kwargs):  # noqa: E501
        """get_pool_destination_volume_data  # noqa: E501

        Get Destination Volume Capacity Data.  # 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_pool_destination_volume_data(id, volname, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param str volname: Destination Volume Name (required)
        :param int start: The item number to start from. 0 starts from the beginning.
        :param int limit: The total number of records to return.
        :return: InlineResponse20079
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_pool_destination_volume_data_with_http_info(id, volname, **kwargs)  # noqa: E501
        else:
            (data) = self.get_pool_destination_volume_data_with_http_info(id, volname, **kwargs)  # noqa: E501
            return data

    def get_pool_destination_volume_data_with_http_info(self, id, volname, **kwargs):  # noqa: E501
        """get_pool_destination_volume_data  # noqa: E501

        Get Destination Volume Capacity Data.  # 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_pool_destination_volume_data_with_http_info(id, volname, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param str volname: Destination Volume Name (required)
        :param int start: The item number to start from. 0 starts from the beginning.
        :param int limit: The total number of records to return.
        :return: InlineResponse20079
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'volname', 'start', 'limit']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_request_timeout')

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^cg-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `get_pool_destination_volume_data`, must conform to the pattern `/^cg-[0-9a-f]{8}$/`")  # noqa: E501
        if self.api_client.client_side_validation and ('volname' in params and not re.search(r'^volume-[0-9a-f]{8}$', params['volname'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `volname` when calling `get_pool_destination_volume_data`, must conform to the pattern `/^volume-[0-9a-f]{8}$/`")  # noqa: E501
        if self.api_client.client_side_validation and ('start' in params and params['start'] < 0):  # noqa: E501
            raise ValueError("Invalid value for parameter `start` when calling `get_pool_destination_volume_data`, must be a value greater than or equal to `0`")  # noqa: E501
        collection_formats = {}

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

        query_params = []
        if 'volname' in params:
            query_params.append(('volname', params['volname']))  # noqa: E501
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501
        if 'limit' in params:
            query_params.append(('limit', params['limit']))  # 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(
            '/pools/{id}/destination_volume_data.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20079',  # 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_pool_mirror_destination_volumes(self, id, **kwargs):  # noqa: E501
        """get_pool_mirror_destination_volumes  # noqa: E501

        List Remote Mirroring Destination Volumes in a Pool.  # 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_pool_mirror_destination_volumes(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param int start: The item number to start from. 0 starts from the beginning.
        :param int limit: The total number of records to return.
        :return: InlineResponse20078
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_pool_mirror_destination_volumes_with_http_info(id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_pool_mirror_destination_volumes_with_http_info(id, **kwargs)  # noqa: E501
            return data

    def get_pool_mirror_destination_volumes_with_http_info(self, id, **kwargs):  # noqa: E501
        """get_pool_mirror_destination_volumes  # noqa: E501

        List Remote Mirroring Destination Volumes in a Pool.  # 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_pool_mirror_destination_volumes_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param int start: The item number to start from. 0 starts from the beginning.
        :param int limit: The total number of records to return.
        :return: InlineResponse20078
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_pool_mirror_destination_volumes" % key
                )
            params[key] = val
        del params['kwargs']
        # 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_pool_mirror_destination_volumes`")  # noqa: E501

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `get_pool_mirror_destination_volumes`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        if self.api_client.client_side_validation and ('start' in params and params['start'] < 0):  # noqa: E501
            raise ValueError("Invalid value for parameter `start` when calling `get_pool_mirror_destination_volumes`, must be a value greater than or equal to `0`")  # noqa: E501
        collection_formats = {}

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

        query_params = []
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501
        if 'limit' in params:
            query_params.append(('limit', params['limit']))  # 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(
            '/pools/{id}/destination_volumes.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20078',  # 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_pool_performance(self, id, **kwargs):  # noqa: E501
        """get_pool_performance  # noqa: E501

        Returns the last 60 data points of performance data for the specified interval.  # 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_pool_performance(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param int interval: The interval between data points, in seconds
        :return: InlineResponse20083
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_pool_performance_with_http_info(id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_pool_performance_with_http_info(id, **kwargs)  # noqa: E501
            return data

    def get_pool_performance_with_http_info(self, id, **kwargs):  # noqa: E501
        """get_pool_performance  # noqa: E501

        Returns the last 60 data points of performance data for the specified interval.  # 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_pool_performance_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param int interval: The interval between data points, in seconds
        :return: InlineResponse20083
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['id', 'interval']  # 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_pool_performance" % key
                )
            params[key] = val
        del params['kwargs']
        # 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_pool_performance`")  # noqa: E501

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `get_pool_performance`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        if self.api_client.client_side_validation and ('interval' in params and params['interval'] < 1):  # noqa: E501
            raise ValueError("Invalid value for parameter `interval` when calling `get_pool_performance`, must be a value greater than or equal to `1`")  # noqa: E501
        collection_formats = {}

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

        query_params = []
        if 'interval' in params:
            query_params.append(('interval', params['interval']))  # 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(
            '/pools/{id}/performance.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20083',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Return the list of RAID Groups in a Pool.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_raid_groups_in_pool(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param int start: The item number to start from. 0 starts from the beginning.
        :param int limit: The total number of records to return.
        :return: InlineResponse20071
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_raid_groups_in_pool_with_http_info(id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_raid_groups_in_pool_with_http_info(id, **kwargs)  # noqa: E501
            return data

    def get_raid_groups_in_pool_with_http_info(self, id, **kwargs):  # noqa: E501
        """get_raid_groups_in_pool  # noqa: E501

        Return the list of RAID Groups in a Pool.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_raid_groups_in_pool_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param int start: The item number to start from. 0 starts from the beginning.
        :param int limit: The total number of records to return.
        :return: InlineResponse20071
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `get_raid_groups_in_pool`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        if self.api_client.client_side_validation and ('start' in params and params['start'] < 0):  # noqa: E501
            raise ValueError("Invalid value for parameter `start` when calling `get_raid_groups_in_pool`, must be a value greater than or equal to `0`")  # noqa: E501
        collection_formats = {}

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

        query_params = []
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501
        if 'limit' in params:
            query_params.append(('limit', params['limit']))  # 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(
            '/pools/{id}/raid_groups.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20071',  # 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_volumes_in_pool(self, id, **kwargs):  # noqa: E501
        """get_volumes_in_pool  # noqa: E501

        Return the list of Volumes in a Pool.  # 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_volumes_in_pool(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param int start: The item number to start from. 0 starts from the beginning.
        :param int limit: The total number of records to return.
        :return: InlineResponse20072
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_volumes_in_pool_with_http_info(id, **kwargs)  # noqa: E501
        else:
            (data) = self.get_volumes_in_pool_with_http_info(id, **kwargs)  # noqa: E501
            return data

    def get_volumes_in_pool_with_http_info(self, id, **kwargs):  # noqa: E501
        """get_volumes_in_pool  # noqa: E501

        Return the list of Volumes in a Pool.  # 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_volumes_in_pool_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param int start: The item number to start from. 0 starts from the beginning.
        :param int limit: The total number of records to return.
        :return: InlineResponse20072
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_volumes_in_pool" % key
                )
            params[key] = val
        del params['kwargs']
        # 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_volumes_in_pool`")  # noqa: E501

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `get_volumes_in_pool`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        if self.api_client.client_side_validation and ('start' in params and params['start'] < 0):  # noqa: E501
            raise ValueError("Invalid value for parameter `start` when calling `get_volumes_in_pool`, must be a value greater than or equal to `0`")  # noqa: E501
        collection_formats = {}

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

        query_params = []
        if 'start' in params:
            query_params.append(('start', params['start']))  # noqa: E501
        if 'limit' in params:
            query_params.append(('limit', params['limit']))  # 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(
            '/pools/{id}/volumes.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20072',  # 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_volumes_in_pool_recycle_bin(self, id, **kwargs):  # noqa: E501
        """get_volumes_in_pool_recycle_bin  # noqa: E501

        Show a pool's volumes in recycle bin  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_volumes_in_pool_recycle_bin(id, async_req=True)
        >>> result = thread.get()

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

    def get_volumes_in_pool_recycle_bin_with_http_info(self, id, **kwargs):  # noqa: E501
        """get_volumes_in_pool_recycle_bin  # noqa: E501

        Show a pool's volumes in recycle bin  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_volumes_in_pool_recycle_bin_with_http_info(id, async_req=True)
        >>> result = thread.get()

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

        all_params = ['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_volumes_in_pool_recycle_bin" % key
                )
            params[key] = val
        del params['kwargs']
        # 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_volumes_in_pool_recycle_bin`")  # noqa: E501

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `get_volumes_in_pool_recycle_bin`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        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(
            '/pools/{id}/volumes_in_recycle_bin.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20082',  # 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 rename_pool(self, id, rename_pool, **kwargs):  # noqa: E501
        """rename_pool  # noqa: E501

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

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

    def rename_pool_with_http_info(self, id, rename_pool, **kwargs):  # noqa: E501
        """rename_pool  # noqa: E501

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

        :param async_req bool
        :param str id: (required)
        :param RenamePool rename_pool: (required)
        :return: InlineResponse20070
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `rename_pool`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'rename_pool' in params:
            body_params = params['rename_pool']
        # 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(
            '/pools/{id}/rename.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20070',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Toggle cache for a Pool.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_pool_cache(id, set_pool_cache, async_req=True)
        >>> result = thread.get()

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

    def set_pool_cache_with_http_info(self, id, set_pool_cache, **kwargs):  # noqa: E501
        """set_pool_cache  # noqa: E501

        Toggle cache for a Pool.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_pool_cache_with_http_info(id, set_pool_cache, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param SetPoolCache set_pool_cache: (required)
        :return: InlineResponse20080
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `set_pool_cache`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

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

        Toggle copy on write cache for a Pool.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_pool_cowcache(id, set_pool_cowcache, async_req=True)
        >>> result = thread.get()

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

    def set_pool_cowcache_with_http_info(self, id, set_pool_cowcache, **kwargs):  # noqa: E501
        """set_pool_cowcache  # noqa: E501

        Toggle copy on write cache for a Pool.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_pool_cowcache_with_http_info(id, set_pool_cowcache, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param SetPoolCowcache set_pool_cowcache: (required)
        :return: InlineResponse20081
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `set_pool_cowcache`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'set_pool_cowcache' in params:
            body_params = params['set_pool_cowcache']
        # 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(
            '/pools/{id}/cow_cache.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20081',  # 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 shrink_pool(self, id, shrink_pool, **kwargs):  # noqa: E501
        """shrink_pool  # noqa: E501

        Remove a RAID Group / Shrink OBS from a Pool.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.shrink_pool(id, shrink_pool, async_req=True)
        >>> result = thread.get()

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

    def shrink_pool_with_http_info(self, id, shrink_pool, **kwargs):  # noqa: E501
        """shrink_pool  # noqa: E501

        Remove a RAID Group / Shrink OBS from a Pool.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.shrink_pool_with_http_info(id, shrink_pool, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param ShrinkPool shrink_pool: (required)
        :return: InlineResponse20074
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `shrink_pool`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'shrink_pool' in params:
            body_params = params['shrink_pool']
        # 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(
            '/pools/{id}/shrink.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20074',  # 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_pool_capacity_alerts(self, id, update_pool_capacity_alerts, **kwargs):  # noqa: E501
        """update_pool_capacity_alerts  # noqa: E501

        Update free capacity alert notification settings for a Pool.  # 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_pool_capacity_alerts(id, update_pool_capacity_alerts, async_req=True)
        >>> result = thread.get()

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

    def update_pool_capacity_alerts_with_http_info(self, id, update_pool_capacity_alerts, **kwargs):  # noqa: E501
        """update_pool_capacity_alerts  # noqa: E501

        Update free capacity alert notification settings for a Pool.  # 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_pool_capacity_alerts_with_http_info(id, update_pool_capacity_alerts, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param UpdatePoolCapacityAlerts update_pool_capacity_alerts: (required)
        :return: InlineResponse20077
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `update_pool_capacity_alerts`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        collection_formats = {}

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

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

        return self.api_client.call_api(
            '/pools/{id}/update_protection.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20077',  # 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_ssd_cool_off(self, id, update_ssd_cool_off, **kwargs):  # noqa: E501
        """update_ssd_cool_off  # noqa: E501

        Update ssd cool off.  # 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_ssd_cool_off(id, update_ssd_cool_off, async_req=True)
        >>> result = thread.get()

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

    def update_ssd_cool_off_with_http_info(self, id, update_ssd_cool_off, **kwargs):  # noqa: E501
        """update_ssd_cool_off  # noqa: E501

        Update ssd cool off.  # 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_ssd_cool_off_with_http_info(id, update_ssd_cool_off, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param UpdateSsdCoolOff update_ssd_cool_off: (required)
        :return: InlineResponse20076
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^r?pool-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `update_ssd_cool_off`, must conform to the pattern `/^r?pool-[0-9a-f]{8}$/`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        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_ssd_cool_off' in params:
            body_params = params['update_ssd_cool_off']
        # 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(
            '/pools/{id}/update_ssd_cool_off.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20076',  # 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)
