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

        Update a object storage backup 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.backup_jobs_rate_limit(id, backup_jobs_rate_limit, async_req=True)
        >>> result = thread.get()

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

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

        Update a object storage backup 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.backup_jobs_rate_limit_with_http_info(id, backup_jobs_rate_limit, async_req=True)
        >>> result = thread.get()

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

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

        if self.api_client.client_side_validation and ('id' in params and not re.search(r'^bkpjobs-[0-9a-f]{8}$', params['id'])):  # noqa: E501
            raise ValueError("Invalid value for parameter `id` when calling `backup_jobs_rate_limit`, must conform to the pattern `/^bkpjobs-[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 'backup_jobs_rate_limit' in params:
            body_params = params['backup_jobs_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(
            '/object_storage_backup_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='InlineResponse200142',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Set compression for object storage backup 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.backup_jobs_update_compression(id, backup_jobs_update_compression, async_req=True)
        >>> result = thread.get()

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

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

        Set compression for object storage backup 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.backup_jobs_update_compression_with_http_info(id, backup_jobs_update_compression, async_req=True)
        >>> result = thread.get()

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

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

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

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

        Break object storage backup 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_ros_backup_job(id, break_ros_backup_job, async_req=True)
        >>> result = thread.get()

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

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

        Break object storage backup 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_ros_backup_job_with_http_info(id, break_ros_backup_job, async_req=True)
        >>> result = thread.get()

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

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

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

        Break object storage restore 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_ros_restore_job(id, async_req=True)
        >>> result = thread.get()

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

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

        Break object storage restore 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_ros_restore_job_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200150
                 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_ros_restore_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_ros_restore_job`")  # noqa: E501

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

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

        Set restore mode for object storage restore 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.change_ros_restore_job_mode(id, change_ros_restore_job_mode, async_req=True)
        >>> result = thread.get()

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

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

        Set restore mode for object storage restore 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.change_ros_restore_job_mode_with_http_info(id, change_ros_restore_job_mode, async_req=True)
        >>> result = thread.get()

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

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

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

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

        Create cloud object storage backup 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.create_ros_backup_job(create_ros_backup_job, async_req=True)
        >>> result = thread.get()

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

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

        Create cloud object storage backup 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.create_ros_backup_job_with_http_info(create_ros_backup_job, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateRosBackupJob create_ros_backup_job: (required)
        :return: InlineResponse200135
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

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

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

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

        :param async_req bool
        :param CreateRosDestination create_ros_destination: (required)
        :return: InlineResponse200128
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        Create object storage restore job. Can be created from object storage key or from object storage snapshot name (key or local_snapname must be supplied)  # 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_ros_restore_job(create_ros_restore_job, async_req=True)
        >>> result = thread.get()

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

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

        Create object storage restore job. Can be created from object storage key or from object storage snapshot name (key or local_snapname must be supplied)  # 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_ros_restore_job_with_http_info(create_ros_restore_job, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param CreateRosRestoreJob create_ros_restore_job: (required)
        :return: InlineResponse200146
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        Returns a list of all Object Storage backup 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.get_all_ros_backup_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: InlineResponse200134
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        if kwargs.get('async_req'):
            return self.get_all_ros_backup_jobs_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.get_all_ros_backup_jobs_with_http_info(**kwargs)  # noqa: E501
            return data

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

        Returns a list of all Object Storage backup 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.get_all_ros_backup_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: InlineResponse200134
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

        params = locals()
        for key, val in six.iteritems(params['kwargs']):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_all_ros_backup_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 `get_all_ros_backup_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(
            '/object_storage_backup_jobs.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200134',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Returns a list of all backup jobs of one specific object storage destination.  # 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_ros_destination_backup_jobs(id, async_req=True)
        >>> result = thread.get()

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

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

        Returns a list of all backup jobs of one specific object storage destination.  # 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_ros_destination_backup_jobs_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200132
                 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_all_ros_destination_backup_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_all_ros_destination_backup_jobs`")  # noqa: E501

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

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

        Returns a list of all restore jobs of one specific Object Storage destination.  # 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_ros_destination_restore_jobs(id, async_req=True)
        >>> result = thread.get()

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

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

        Returns a list of all restore jobs of one specific Object Storage destination.  # 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_ros_destination_restore_jobs_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200133
                 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_all_ros_destination_restore_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_all_ros_destination_restore_jobs`")  # noqa: E501

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

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

        Returns a List of all remote Object Storages.  # 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_ros_destinations(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: InlineResponse200127
                 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_ros_destinations_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.get_all_ros_destinations_with_http_info(**kwargs)  # noqa: E501
            return data

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

        Returns a List of all remote Object Storages.  # 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_ros_destinations_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: InlineResponse200127
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

        if self.api_client.client_side_validation and ('start' in params and params['start'] < 0):  # noqa: E501
            raise ValueError("Invalid value for parameter `start` when calling `get_all_ros_destinations`, 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(
            '/object_storage_destinations.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200127',  # 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_ros_restore_jobs(self, **kwargs):  # noqa: E501
        """get_all_ros_restore_jobs  # noqa: E501

        Returns a List of all Object Storage restore 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.get_all_ros_restore_jobs(async_req=True)
        >>> result = thread.get()

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

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

        Returns a List of all Object Storage restore 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.get_all_ros_restore_jobs_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: InlineResponse200145
                 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_ros_restore_jobs" % 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(
            '/object_storage_restore_jobs.json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200145',  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get('async_req'),
            _return_http_data_only=params.get('_return_http_data_only'),
            _preload_content=params.get('_preload_content', True),
            _request_timeout=params.get('_request_timeout'),
            collection_formats=collection_formats)

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

        Returns the details of Object Storage backup 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_ros_backup_job(id, async_req=True)
        >>> result = thread.get()

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

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

        Returns the details of Object Storage backup 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_ros_backup_job_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200136
                 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_ros_backup_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 `get_ros_backup_job`")  # noqa: E501

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

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

        Returns the details for Object Storage backup job performance.  # 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_ros_backup_job_performance(id, async_req=True)
        >>> result = thread.get()

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

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

        Returns the details for Object Storage backup job performance.  # 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_ros_backup_job_performance_with_http_info(id, async_req=True)
        >>> result = thread.get()

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

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

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

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

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

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

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

        Returns the details for a specific Object Storage destinations.  # 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_ros_destination(id, async_req=True)
        >>> result = thread.get()

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

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

        Returns the details for a specific Object Storage destinations.  # 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_ros_destination_with_http_info(id, async_req=True)
        >>> result = thread.get()

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

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

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

        Returns the details for Object Storage restore 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_ros_restore_job(id, async_req=True)
        >>> result = thread.get()

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

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

        Returns the details for Object Storage restore 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_ros_restore_job_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200147
                 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_ros_restore_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 `get_ros_restore_job`")  # noqa: E501

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

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

        Returns the details for Object Storage restore job performance.  # 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_ros_restore_job_performance(id, async_req=True)
        >>> result = thread.get()

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

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

        Returns the details for Object Storage restore job performance.  # 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_ros_restore_job_performance_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :param str interval: Interval in seconds between metered data
        :return: InlineResponse200152
                 If the method is called asynchronously,
                 returns the request thread.
        """

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

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

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

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

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

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

        Pause object storage backup 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_ros_backup_job(id, async_req=True)
        >>> result = thread.get()

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

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

        Pause object storage backup 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_ros_backup_job_with_http_info(id, async_req=True)
        >>> result = thread.get()

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

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

        Pause object storage restore 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_ros_restore_job(id, async_req=True)
        >>> result = thread.get()

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

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

        Pause object storage restore 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_ros_restore_job_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200148
                 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_ros_restore_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_ros_restore_job`")  # noqa: E501

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

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

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

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

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

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

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

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

        Replace snapshot policy for object storage backup 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.replace_ros_backup_job_snapshot_policy(id, replace_ros_backup_job_snapshot_policy, async_req=True)
        >>> result = thread.get()

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

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

        Replace snapshot policy for object storage backup 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.replace_ros_backup_job_snapshot_policy_with_http_info(id, replace_ros_backup_job_snapshot_policy, async_req=True)
        >>> result = thread.get()

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

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

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

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

        Continue object storage backup 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_ros_backup_job(id, async_req=True)
        >>> result = thread.get()

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

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

        Continue object storage backup 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_ros_backup_job_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param str id: (required)
        :return: InlineResponse200139
                 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_ros_backup_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_ros_backup_job`")  # noqa: E501

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

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

        Continue object storage restore 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_ros_restore_job(id, async_req=True)
        >>> result = thread.get()

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

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

        Continue object storage restore 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_ros_restore_job_with_http_info(id, async_req=True)
        >>> result = thread.get()

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

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

        Update a object storage backup job S3 storage class. only if Object storage destination is AWS S3.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_obs_backup_job_class(id, set_obs_backup_job_class, async_req=True)
        >>> result = thread.get()

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

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

        Update a object storage backup job S3 storage class. only if Object storage destination is AWS S3.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_obs_backup_job_class_with_http_info(id, set_obs_backup_job_class, async_req=True)
        >>> result = thread.get()

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

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

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

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

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

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

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

        Update a remote object storage.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_ros_destination_with_http_info(id, update_ros_destination, async_req=True)
        >>> result = thread.get()

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

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