# 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 MirroringAndCloningApi(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_mirror_snapshot_policy(self, id, add_mirror_snapshot_policy, **kwargs):  # noqa: E501
        """add_mirror_snapshot_policy  # noqa: E501

        Adds an additional snapshot policy to an existing mirror job.  # 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_mirror_snapshot_policy(id, add_mirror_snapshot_policy, async_req=True)
        >>> result = thread.get()

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

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

        Adds an additional snapshot policy to an existing mirror job.  # 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_mirror_snapshot_policy_with_http_info(id, add_mirror_snapshot_policy, async_req=True)
        >>> result = thread.get()

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

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^(src|dst)jvpsa-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `add_mirror_snapshot_policy`, must conform to the pattern `/^(src|dst)jvpsa-[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 'add_mirror_snapshot_policy' in params:
            body_params = params['add_mirror_snapshot_policy']
        # 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(
            '/mirror_jobs/{id}/attach_snapshot_policy.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200114',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Attach a Snapshot Policy to a Volume.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.attach_snapshot_policy_to_vpsa_mirror_job(jobname, attach_snapshot_policy_to_vpsa_mirror_job, async_req=True)
        >>> result = thread.get()

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

    def attach_snapshot_policy_to_vpsa_mirror_job_with_http_info(self, jobname, attach_snapshot_policy_to_vpsa_mirror_job, **kwargs):  # noqa: E501
        """attach_snapshot_policy_to_vpsa_mirror_job  # noqa: E501

        Attach a Snapshot Policy to a Volume.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.attach_snapshot_policy_to_vpsa_mirror_job_with_http_info(jobname, attach_snapshot_policy_to_vpsa_mirror_job, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str jobname: (required)
        :param AttachSnapshotPolicyToVpsaMirrorJob attach_snapshot_policy_to_vpsa_mirror_job: (required)
        :return: InlineResponse200113
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

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

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

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

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200125
                 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 break_remote_clone_job" % 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 `break_remote_clone_job`")  # 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(
            '/remote_clones/{id}/break.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200125',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

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

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

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

        Breaks a Remote Mirror Job.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.break_vpsa_mirror_job_with_http_info(id, break_vpsa_mirror_job, async_req=True)
        >>> result = thread.get()

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

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^(src|dst)jvpsa-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `break_vpsa_mirror_job`, must conform to the pattern `/^(src|dst)jvpsa-[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 'break_vpsa_mirror_job' in params:
            body_params = params['break_vpsa_mirror_job']
        # 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(
            '/mirror_jobs/{id}/break.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 clone_mirror_job(self, id, clone_mirror_job, **kwargs):  # noqa: E501
        """clone_mirror_job  # noqa: E501

        Clone a mirror job's snapshot into a volume.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.clone_mirror_job(id, clone_mirror_job, async_req=True)
        >>> result = thread.get()

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

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

        Clone a mirror job's snapshot into a volume.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.clone_mirror_job_with_http_info(id, clone_mirror_job, async_req=True)
        >>> result = thread.get()

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

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^(src|dst)jvpsa-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `clone_mirror_job`, must conform to the pattern `/^(src|dst)jvpsa-[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 'clone_mirror_job' in params:
            body_params = params['clone_mirror_job']
        # 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(
            '/mirror_jobs/{id}/clone_snapshot.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200118',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Continue a Paused Remote Mirror Job.  # 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_vpsa_mirror_job(id, async_req=True)
        >>> result = thread.get()

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

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

        Continue a Paused Remote Mirror Job.  # 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_vpsa_mirror_job_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200101
                 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 continue_vpsa_mirror_job" % 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 `continue_vpsa_mirror_job`")  # noqa: E501

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^(src|dst)jvpsa-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `continue_vpsa_mirror_job`, must conform to the pattern `/^(src|dst)jvpsa-[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(
            '/mirror_jobs/{id}/continue.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200101',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Create a Remote Clone.  # 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_remote_clone(create_remote_clone, async_req=True)
        >>> result = thread.get()

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

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

        Create a Remote Clone.  # 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_remote_clone_with_http_info(create_remote_clone, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateRemoteClone create_remote_clone: (required)
        :return: InlineResponse200121
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        Detach a Snapshot Policy from a Mirror job.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.detach_snapshot_policy_from_vol(job_id, detach_snapshot_policy_from_vol, async_req=True)
        >>> result = thread.get()

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

    def detach_snapshot_policy_from_vol_with_http_info(self, job_id, detach_snapshot_policy_from_vol, **kwargs):  # noqa: E501
        """detach_snapshot_policy_from_vol  # noqa: E501

        Detach a Snapshot Policy from a Mirror job.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.detach_snapshot_policy_from_vol_with_http_info(job_id, detach_snapshot_policy_from_vol, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str job_id: (required)
        :param DetachSnapshotPolicyFromVol detach_snapshot_policy_from_vol: (required)
        :return: InlineResponse200115
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        Discover and connect a Remote VPSA. Must supply User credentials of the remote VPSA and define if the discovery is done via a Public IP or the Management IP  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.discover_remote_vpsa(discover_remote_vpsa, async_req=True)
        >>> result = thread.get()

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

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

        Discover and connect a Remote VPSA. Must supply User credentials of the remote VPSA and define if the discovery is done via a Public IP or the Management IP  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.discover_remote_vpsa_with_http_info(discover_remote_vpsa, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param DiscoverRemoteVpsa discover_remote_vpsa: (required)
        :return: InlineResponse200105
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

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

        List the VPSA Remote Clones.  # 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_remote_clones(async_req=True)
        >>> result = thread.get()

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

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

        List the VPSA Remote Clones.  # 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_remote_clones_with_http_info(async_req=True)
        >>> result = thread.get()

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

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

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

        Show a Remote Clone.  # 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_remote_clone(id, async_req=True)
        >>> result = thread.get()

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

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

        Show a Remote Clone.  # 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_remote_clone_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200123
                 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_remote_clone" % 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_remote_clone`")  # 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(
            '/remote_clones/{id}.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200123',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        List the Pools in a Remote VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_remote_vpsa_pools(id, async_req=True)
        >>> result = thread.get()

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

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

        List the Pools in a Remote VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_remote_vpsa_pools_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200109
                 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_remote_vpsa_pools" % 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_remote_vpsa_pools`")  # noqa: E501

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^rvpsa-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `get_remote_vpsa_pools`, must conform to the pattern `/^rvpsa-[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(
            '/remote_vpsas/{id}/pools.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200109',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Get all snapshots created by a mirror job.  # 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_snapshots(id, async_req=True)
        >>> result = thread.get()

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

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

        Get all snapshots created by a mirror job.  # 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_snapshots_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200117
                 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_snapshots" % 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_snapshots`")  # noqa: E501

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^(src|dst)jvpsa-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `get_snapshots`, must conform to the pattern `/^(src|dst)jvpsa-[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(
            '/mirror_jobs/{id}/snapshots.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200117',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        List Volumes on the remote VPSA which are candidates for resuming Remote Mirroring relationship. Typically, those Volumes were part of a mirror relationship in the past and still have a snapshots that correlates to an existing snapshot in the local VPSA. Those identical snapshots will be used to resume mirroring relationship  # 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_suggested_mirror_jobs(id, cgname, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param str cgname: CG ID for the local Volume. (required)
        :return: InlineResponse200110
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_suggested_mirror_jobs_with_http_info(id, cgname, **kwargs)  # noqa: E501
        else:
            (data) = self.get_suggested_mirror_jobs_with_http_info(id, cgname, **kwargs)  # noqa: E501
            return data

    def get_suggested_mirror_jobs_with_http_info(self, id, cgname, **kwargs):  # noqa: E501
        """get_suggested_mirror_jobs  # noqa: E501

        List Volumes on the remote VPSA which are candidates for resuming Remote Mirroring relationship. Typically, those Volumes were part of a mirror relationship in the past and still have a snapshots that correlates to an existing snapshot in the local VPSA. Those identical snapshots will be used to resume mirroring relationship  # 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_suggested_mirror_jobs_with_http_info(id, cgname, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param str cgname: CG ID for the local Volume. (required)
        :return: InlineResponse200110
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

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

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

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

        Pause a Remote Clone Job.  # 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_remote_clone(id, async_req=True)
        >>> result = thread.get()

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

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

        Pause a Remote Clone Job.  # 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_remote_clone_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200124
                 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 pause_remote_clone" % 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 `pause_remote_clone`")  # 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(
            '/remote_clones/{id}/pause.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200124',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Pause a Remote Mirror Job.  # 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_vpsa_mirror_job(id, async_req=True)
        >>> result = thread.get()

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

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

        Pause a Remote Mirror Job.  # 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_vpsa_mirror_job_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200100
                 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 pause_vpsa_mirror_job" % 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 `pause_vpsa_mirror_job`")  # noqa: E501

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^(src|dst)jvpsa-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `pause_vpsa_mirror_job`, must conform to the pattern `/^(src|dst)jvpsa-[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(
            '/mirror_jobs/{id}/pause.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200100',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Refresh discovered data about a Remote 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.refresh_remote_vpsa(id, async_req=True)
        >>> result = thread.get()

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

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

        Refresh discovered data about a Remote 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.refresh_remote_vpsa_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200108
                 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 refresh_remote_vpsa" % 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 `refresh_remote_vpsa`")  # noqa: E501

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^rvpsa-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `refresh_remote_vpsa`, must conform to the pattern `/^rvpsa-[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(
            '/remote_vpsas/{id}/refresh.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200108',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Delete the local record of a Remote VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_remote_vpsa(id, async_req=True)
        >>> result = thread.get()

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

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

        Delete the local record of a Remote VPSA.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_remote_vpsa_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200107
                 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 remove_remote_vpsa" % 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 `remove_remote_vpsa`")  # 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(
            '/remote_vpsas/{id}.json', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200107',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Resume a Remote Mirroring relationship between a local Volume snapshot and an remote Volume Snapshot on the remote 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.resume_broken_mirror(id, resume_broken_mirror, async_req=True)
        >>> result = thread.get()

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

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

        Resume a Remote Mirroring relationship between a local Volume snapshot and an remote Volume Snapshot on the remote 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.resume_broken_mirror_with_http_info(id, resume_broken_mirror, async_req=True)
        >>> result = thread.get()

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

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

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^rvpsa-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `resume_broken_mirror`, must conform to the pattern `/^rvpsa-[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 'resume_broken_mirror' in params:
            body_params = params['resume_broken_mirror']
        # 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(
            '/remote_vpsas/{id}/resume_mirror_job.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200111',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Continue a Paused Remote Clone Job.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.resume_remote_clone_job(id, async_req=True)
        >>> result = thread.get()

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

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

        Continue a Paused Remote Clone Job.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.resume_remote_clone_job_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200124
                 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 resume_remote_clone_job" % 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 `resume_remote_clone_job`")  # 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(
            '/remote_clones/{id}/continue.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200124',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        List the Volumes in a Remote 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.show_remote_cgs(id, async_req=True)
        >>> result = thread.get()

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

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

        List the Volumes in a Remote 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.show_remote_cgs_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200119
                 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 show_remote_cgs" % 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 `show_remote_cgs`")  # 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(
            '/remote_vpsas/{id}/volumes.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200119',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

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

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

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

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

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse20099
                 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 show_remote_mirror_job" % 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 `show_remote_mirror_job`")  # noqa: E501

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^(src|dst)jvpsa-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `show_remote_mirror_job`, must conform to the pattern `/^(src|dst)jvpsa-[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(
            '/mirror_jobs/{id}.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20099',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        List the snapshots in a Remote VPSA volume.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.show_remote_snapshots_on_cg(id, show_remote_snapshots_on_cg, async_req=True)
        >>> result = thread.get()

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

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

        List the snapshots in a Remote VPSA volume.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.show_remote_snapshots_on_cg_with_http_info(id, show_remote_snapshots_on_cg, async_req=True)
        >>> result = thread.get()

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

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

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

        Get information about a single Remote 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.show_remote_vpsa(id, async_req=True)
        >>> result = thread.get()

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

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

        Get information about a single Remote 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.show_remote_vpsa_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200106
                 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 show_remote_vpsa" % 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 `show_remote_vpsa`")  # noqa: E501

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^rvpsa-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `show_remote_vpsa`, must conform to the pattern `/^rvpsa-[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(
            '/remote_vpsas/{id}.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200106',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        List all Remote VPSAs.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.show_remote_vpsas(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: InlineResponse200104
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.show_remote_vpsas_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.show_remote_vpsas_with_http_info(**kwargs)  # noqa: E501
            return data

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

        List all Remote VPSAs.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.show_remote_vpsas_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: InlineResponse200104
                 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 show_remote_vpsas" % 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 `show_remote_vpsas`, 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(
            '/remote_vpsas.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200104',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Show all Remote Mirror Jobs.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.show_vpsa_mirror_jobs(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: InlineResponse20098
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.show_vpsa_mirror_jobs_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.show_vpsa_mirror_jobs_with_http_info(**kwargs)  # noqa: E501
            return data

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

        Show all Remote Mirror Jobs.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.show_vpsa_mirror_jobs_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: InlineResponse20098
                 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 show_vpsa_mirror_jobs" % 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 `show_vpsa_mirror_jobs`, 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(
            '/mirror_jobs.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 switch_remote_clone_mode(self, id, switch_remote_clone_mode, **kwargs):  # noqa: E501
        """switch_remote_clone_mode  # noqa: E501

        Switch a Remote Clone Job clone mode.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.switch_remote_clone_mode(id, switch_remote_clone_mode, async_req=True)
        >>> result = thread.get()

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

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

        Switch a Remote Clone Job clone mode.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.switch_remote_clone_mode_with_http_info(id, switch_remote_clone_mode, async_req=True)
        >>> result = thread.get()

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

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

        Update a mirror job rate limit (kb/s)  # 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_mirror_rate_limit(id, update_mirror_rate_limit, async_req=True)
        >>> result = thread.get()

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

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

        Update a mirror job rate limit (kb/s)  # 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_mirror_rate_limit_with_http_info(id, update_mirror_rate_limit, async_req=True)
        >>> result = thread.get()

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

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

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^(src|dst)jvpsa-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `update_mirror_rate_limit`, must conform to the pattern `/^(src|dst)jvpsa-[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_mirror_rate_limit' in params:
            body_params = params['update_mirror_rate_limit']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json', 'application/xml'])  # noqa: E501

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

        return self.api_client.call_api(
            '/mirror_jobs/{id}/rate_limit.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 update_mirror_wan_optimization(self, id, update_mirror_wan_optimization, **kwargs):  # noqa: E501
        """update_mirror_wan_optimization  # noqa: E501

        Update a Mirror's WAN optimization.  # 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_mirror_wan_optimization(id, update_mirror_wan_optimization, async_req=True)
        >>> result = thread.get()

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

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

        Update a Mirror's WAN optimization.  # 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_mirror_wan_optimization_with_http_info(id, update_mirror_wan_optimization, async_req=True)
        >>> result = thread.get()

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

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^(src|dst)jvpsa-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `update_mirror_wan_optimization`, must conform to the pattern `/^(src|dst)jvpsa-[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_mirror_wan_optimization' in params:
            body_params = params['update_mirror_wan_optimization']
        # 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(
            '/mirror_jobs/{id}/set_wan_optimization.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200116',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Update a remote vpsa rate limit (kb/s)  # 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_remote_vpsa_rate(id, update_remote_vpsa_rate, async_req=True)
        >>> result = thread.get()

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

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

        Update a remote vpsa rate limit (kb/s)  # 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_remote_vpsa_rate_with_http_info(id, update_remote_vpsa_rate, async_req=True)
        >>> result = thread.get()

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

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^rvpsa-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `update_remote_vpsa_rate`, must conform to the pattern `/^rvpsa-[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_remote_vpsa_rate' in params:
            body_params = params['update_remote_vpsa_rate']
        # 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(
            '/remote_vpsas/{id}/rate_limit.json', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200112',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)
