# coding: utf-8

"""
CloudApi.py
Copyright 2016 SmartBear Software

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
"""

from __future__ import absolute_import

import sys
import os
import re

# python 2 and python 3 compatibility library
from six import iteritems

from ..configuration import Configuration
from ..api_client import ApiClient


class CloudApi(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):
        config = Configuration()
        if api_client:
            self.api_client = api_client
        else:
            if not config.api_client:
                config.api_client = ApiClient()
            self.api_client = config.api_client

    def create_cloud_access_item(self, cloud_access_item, **kwargs):
        """
        
        Add a cluster identifier to access list.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_cloud_access_item(cloud_access_item, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param CloudAccessItem cloud_access_item:  (required)
        :return: Empty
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_access_item']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_access_item' is set
        if ('cloud_access_item' not in params) or (params['cloud_access_item'] is None):
            raise ValueError("Missing the required parameter `cloud_access_item` when calling `create_cloud_access_item`")


        resource_path = '/platform/3/cloud/access'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'cloud_access_item' in params:
            body_params = params['cloud_access_item']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Empty',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def create_cloud_account(self, cloud_account, **kwargs):
        """
        
        Create a new account.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_cloud_account(cloud_account, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param CloudAccountCreateParams cloud_account:  (required)
        :return: CreateCloudAccountResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_account']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_account' is set
        if ('cloud_account' not in params) or (params['cloud_account'] is None):
            raise ValueError("Missing the required parameter `cloud_account` when calling `create_cloud_account`")


        resource_path = '/platform/3/cloud/accounts'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'cloud_account' in params:
            body_params = params['cloud_account']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='CreateCloudAccountResponse',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def create_cloud_job(self, cloud_job, **kwargs):
        """
        
        Create a new job.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_cloud_job(cloud_job, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param CloudJobCreateParams cloud_job:  (required)
        :return: CreateCloudJobResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_job']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_job' is set
        if ('cloud_job' not in params) or (params['cloud_job'] is None):
            raise ValueError("Missing the required parameter `cloud_job` when calling `create_cloud_job`")


        resource_path = '/platform/3/cloud/jobs'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'cloud_job' in params:
            body_params = params['cloud_job']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='CreateCloudJobResponse',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def create_cloud_pool(self, cloud_pool, **kwargs):
        """
        
        Create a new pool.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_cloud_pool(cloud_pool, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param CloudPoolCreateParams cloud_pool:  (required)
        :return: CreateCloudPoolResponse
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_pool']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_pool' is set
        if ('cloud_pool' not in params) or (params['cloud_pool'] is None):
            raise ValueError("Missing the required parameter `cloud_pool` when calling `create_cloud_pool`")


        resource_path = '/platform/3/cloud/pools'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'cloud_pool' in params:
            body_params = params['cloud_pool']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='CreateCloudPoolResponse',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def create_settings_encryption_key_item(self, **kwargs):
        """
        
        Regenerate master encryption key.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_settings_encryption_key_item(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :return: Empty
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []
        all_params.append('callback')

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



        resource_path = '/platform/3/cloud/settings/encryption-key'.replace('{format}', 'json')
        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'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='Empty',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def create_settings_reporting_eula_item(self, settings_reporting_eula_item, **kwargs):
        """
        
        Accept telemetry collection EULA.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.create_settings_reporting_eula_item(settings_reporting_eula_item, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param SettingsReportingEulaItem settings_reporting_eula_item:  (required)
        :return: SettingsReportingEulaItem
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['settings_reporting_eula_item']
        all_params.append('callback')

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

        # verify the required parameter 'settings_reporting_eula_item' is set
        if ('settings_reporting_eula_item' not in params) or (params['settings_reporting_eula_item'] is None):
            raise ValueError("Missing the required parameter `settings_reporting_eula_item` when calling `create_settings_reporting_eula_item`")


        resource_path = '/platform/3/cloud/settings/reporting-eula'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'settings_reporting_eula_item' in params:
            body_params = params['settings_reporting_eula_item']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'POST',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SettingsReportingEulaItem',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_cloud_access_guid(self, cloud_access_guid, **kwargs):
        """
        
        Delete cloud access.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_cloud_access_guid(cloud_access_guid, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str cloud_access_guid: Delete cloud access. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_access_guid']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_access_guid' is set
        if ('cloud_access_guid' not in params) or (params['cloud_access_guid'] is None):
            raise ValueError("Missing the required parameter `cloud_access_guid` when calling `delete_cloud_access_guid`")


        resource_path = '/platform/3/cloud/access/{CloudAccessGuid}'.replace('{format}', 'json')
        path_params = {}
        if 'cloud_access_guid' in params:
            path_params['CloudAccessGuid'] = params['cloud_access_guid']

        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'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_cloud_account(self, cloud_account_id, **kwargs):
        """
        
        Delete cloud account.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_cloud_account(cloud_account_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str cloud_account_id: Delete cloud account. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_account_id']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_account_id' is set
        if ('cloud_account_id' not in params) or (params['cloud_account_id'] is None):
            raise ValueError("Missing the required parameter `cloud_account_id` when calling `delete_cloud_account`")


        resource_path = '/platform/3/cloud/accounts/{CloudAccountId}'.replace('{format}', 'json')
        path_params = {}
        if 'cloud_account_id' in params:
            path_params['CloudAccountId'] = params['cloud_account_id']

        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'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_cloud_pool(self, cloud_pool_id, **kwargs):
        """
        
        Delete a cloud pool.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_cloud_pool(cloud_pool_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str cloud_pool_id: Delete a cloud pool. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_pool_id']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_pool_id' is set
        if ('cloud_pool_id' not in params) or (params['cloud_pool_id'] is None):
            raise ValueError("Missing the required parameter `cloud_pool_id` when calling `delete_cloud_pool`")


        resource_path = '/platform/3/cloud/pools/{CloudPoolId}'.replace('{format}', 'json')
        path_params = {}
        if 'cloud_pool_id' in params:
            path_params['CloudPoolId'] = params['cloud_pool_id']

        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'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def delete_settings_reporting_eula(self, **kwargs):
        """
        
        Revoke acceptance of telemetry collection EULA.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.delete_settings_reporting_eula(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []
        all_params.append('callback')

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



        resource_path = '/platform/3/cloud/settings/reporting-eula'.replace('{format}', 'json')
        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'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'DELETE',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_cloud_access_guid(self, cloud_access_guid, **kwargs):
        """
        
        Retrieve cloud access information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_cloud_access_guid(cloud_access_guid, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str cloud_access_guid: Retrieve cloud access information. (required)
        :return: CloudAccess
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_access_guid']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_access_guid' is set
        if ('cloud_access_guid' not in params) or (params['cloud_access_guid'] is None):
            raise ValueError("Missing the required parameter `cloud_access_guid` when calling `get_cloud_access_guid`")


        resource_path = '/platform/3/cloud/access/{CloudAccessGuid}'.replace('{format}', 'json')
        path_params = {}
        if 'cloud_access_guid' in params:
            path_params['CloudAccessGuid'] = params['cloud_access_guid']

        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'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='CloudAccess',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_cloud_account(self, cloud_account_id, **kwargs):
        """
        
        Retrieve cloud account information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_cloud_account(cloud_account_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str cloud_account_id: Retrieve cloud account information. (required)
        :return: CloudAccounts
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_account_id']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_account_id' is set
        if ('cloud_account_id' not in params) or (params['cloud_account_id'] is None):
            raise ValueError("Missing the required parameter `cloud_account_id` when calling `get_cloud_account`")


        resource_path = '/platform/3/cloud/accounts/{CloudAccountId}'.replace('{format}', 'json')
        path_params = {}
        if 'cloud_account_id' in params:
            path_params['CloudAccountId'] = params['cloud_account_id']

        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'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='CloudAccounts',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_cloud_job(self, cloud_job_id, **kwargs):
        """
        
        Retrieve cloudpool job information.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_cloud_job(cloud_job_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str cloud_job_id: Retrieve cloudpool job information. (required)
        :return: CloudJobs
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_job_id']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_job_id' is set
        if ('cloud_job_id' not in params) or (params['cloud_job_id'] is None):
            raise ValueError("Missing the required parameter `cloud_job_id` when calling `get_cloud_job`")


        resource_path = '/platform/3/cloud/jobs/{CloudJobId}'.replace('{format}', 'json')
        path_params = {}
        if 'cloud_job_id' in params:
            path_params['CloudJobId'] = params['cloud_job_id']

        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'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='CloudJobs',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_cloud_jobs_file(self, cloud_jobs_file_id, **kwargs):
        """
        
        Retrieve files associated with a cloudpool job.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_cloud_jobs_file(cloud_jobs_file_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str cloud_jobs_file_id: Retrieve files associated with a cloudpool job. (required)
        :param str sort: The field that will be used for sorting.
        :param str resume: Continue returning results from previous call using this token (token should come from the previous call, resume cannot be used with other options).
        :param bool batch: If true, only \"limit\" and \"page\" arguments are honored.  Query will return all results, unsorted, as quickly as possible.
        :param int limit: Return no more than this many results at once (see resume).
        :param int page: Works only when \"batch\" parameter and \"limit\" parameters are specified.  Indicates which the page index of results to be returned
        :param str dir: The direction of the sort.
        :return: CloudJobsFiles
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_jobs_file_id', 'sort', 'resume', 'batch', 'limit', 'page', 'dir']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_jobs_file_id' is set
        if ('cloud_jobs_file_id' not in params) or (params['cloud_jobs_file_id'] is None):
            raise ValueError("Missing the required parameter `cloud_jobs_file_id` when calling `get_cloud_jobs_file`")

        if 'limit' in params and params['limit'] < 1.0: 
            raise ValueError("Invalid value for parameter `limit` when calling `get_cloud_jobs_file`, must be a value greater than or equal to `1.0`")

        resource_path = '/platform/3/cloud/jobs-files/{CloudJobsFileId}'.replace('{format}', 'json')
        path_params = {}
        if 'cloud_jobs_file_id' in params:
            path_params['CloudJobsFileId'] = params['cloud_jobs_file_id']

        query_params = {}
        if 'sort' in params:
            query_params['sort'] = params['sort']
        if 'resume' in params:
            query_params['resume'] = params['resume']
        if 'batch' in params:
            query_params['batch'] = params['batch']
        if 'limit' in params:
            query_params['limit'] = params['limit']
        if 'page' in params:
            query_params['page'] = params['page']
        if 'dir' in params:
            query_params['dir'] = params['dir']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='CloudJobsFiles',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_cloud_pool(self, cloud_pool_id, **kwargs):
        """
        
        Retrieve cloud pool information

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_cloud_pool(cloud_pool_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str cloud_pool_id: Retrieve cloud pool information (required)
        :return: CloudPools
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_pool_id']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_pool_id' is set
        if ('cloud_pool_id' not in params) or (params['cloud_pool_id'] is None):
            raise ValueError("Missing the required parameter `cloud_pool_id` when calling `get_cloud_pool`")


        resource_path = '/platform/3/cloud/pools/{CloudPoolId}'.replace('{format}', 'json')
        path_params = {}
        if 'cloud_pool_id' in params:
            path_params['CloudPoolId'] = params['cloud_pool_id']

        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'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='CloudPools',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def get_cloud_settings(self, **kwargs):
        """
        
        List all cloud settings.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.get_cloud_settings(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :return: CloudSettings
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []
        all_params.append('callback')

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



        resource_path = '/platform/3/cloud/settings'.replace('{format}', 'json')
        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'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='CloudSettings',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def list_cloud_access(self, **kwargs):
        """
        
        List all accessible cluster identifiers.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.list_cloud_access(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str sort: The field that will be used for sorting.
        :param int limit: Return no more than this many results at once (see resume).
        :param str dir: The direction of the sort.
        :return: CloudAccessExtended
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['sort', 'limit', 'dir']
        all_params.append('callback')

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


        if 'limit' in params and params['limit'] < 1.0: 
            raise ValueError("Invalid value for parameter `limit` when calling `list_cloud_access`, must be a value greater than or equal to `1.0`")

        resource_path = '/platform/3/cloud/access'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'sort' in params:
            query_params['sort'] = params['sort']
        if 'limit' in params:
            query_params['limit'] = params['limit']
        if 'dir' in params:
            query_params['dir'] = params['dir']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='CloudAccessExtended',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def list_cloud_accounts(self, **kwargs):
        """
        
        List all accounts.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.list_cloud_accounts(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str sort: The field that will be used for sorting.
        :param int limit: Return no more than this many results at once (see resume).
        :param str dir: The direction of the sort.
        :return: CloudAccountsExtended
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['sort', 'limit', 'dir']
        all_params.append('callback')

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


        if 'limit' in params and params['limit'] < 1.0: 
            raise ValueError("Invalid value for parameter `limit` when calling `list_cloud_accounts`, must be a value greater than or equal to `1.0`")

        resource_path = '/platform/3/cloud/accounts'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'sort' in params:
            query_params['sort'] = params['sort']
        if 'limit' in params:
            query_params['limit'] = params['limit']
        if 'dir' in params:
            query_params['dir'] = params['dir']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='CloudAccountsExtended',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def list_cloud_jobs(self, **kwargs):
        """
        
        List all cloudpools jobs.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.list_cloud_jobs(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str sort: The field that will be used for sorting.
        :param int limit: Return no more than this many results at once (see resume).
        :param str dir: The direction of the sort.
        :return: CloudJobsExtended
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['sort', 'limit', 'dir']
        all_params.append('callback')

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


        if 'limit' in params and params['limit'] < 1.0: 
            raise ValueError("Invalid value for parameter `limit` when calling `list_cloud_jobs`, must be a value greater than or equal to `1.0`")

        resource_path = '/platform/3/cloud/jobs'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'sort' in params:
            query_params['sort'] = params['sort']
        if 'limit' in params:
            query_params['limit'] = params['limit']
        if 'dir' in params:
            query_params['dir'] = params['dir']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='CloudJobsExtended',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def list_cloud_pools(self, **kwargs):
        """
        
        List all pools.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.list_cloud_pools(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param str sort: The field that will be used for sorting.
        :param int limit: Return no more than this many results at once (see resume).
        :param str dir: The direction of the sort.
        :return: CloudPoolsExtended
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['sort', 'limit', 'dir']
        all_params.append('callback')

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


        if 'limit' in params and params['limit'] < 1.0: 
            raise ValueError("Invalid value for parameter `limit` when calling `list_cloud_pools`, must be a value greater than or equal to `1.0`")

        resource_path = '/platform/3/cloud/pools'.replace('{format}', 'json')
        path_params = {}

        query_params = {}
        if 'sort' in params:
            query_params['sort'] = params['sort']
        if 'limit' in params:
            query_params['limit'] = params['limit']
        if 'dir' in params:
            query_params['dir'] = params['dir']

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='CloudPoolsExtended',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def list_settings_reporting_eula(self, **kwargs):
        """
        
        View telemetry collection EULA acceptance and content URI.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.list_settings_reporting_eula(callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :return: SettingsReportingEulaItem
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []
        all_params.append('callback')

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



        resource_path = '/platform/3/cloud/settings/reporting-eula'.replace('{format}', 'json')
        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'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'GET',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type='SettingsReportingEulaItem',
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def update_cloud_account(self, cloud_account, cloud_account_id, **kwargs):
        """
        
        Modify cloud account.  All fields are optional, but one or more must be supplied.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_cloud_account(cloud_account, cloud_account_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param CloudAccount cloud_account:  (required)
        :param str cloud_account_id: Modify cloud account.  All fields are optional, but one or more must be supplied. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_account', 'cloud_account_id']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_account' is set
        if ('cloud_account' not in params) or (params['cloud_account'] is None):
            raise ValueError("Missing the required parameter `cloud_account` when calling `update_cloud_account`")
        # verify the required parameter 'cloud_account_id' is set
        if ('cloud_account_id' not in params) or (params['cloud_account_id'] is None):
            raise ValueError("Missing the required parameter `cloud_account_id` when calling `update_cloud_account`")


        resource_path = '/platform/3/cloud/accounts/{CloudAccountId}'.replace('{format}', 'json')
        path_params = {}
        if 'cloud_account_id' in params:
            path_params['CloudAccountId'] = params['cloud_account_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'cloud_account' in params:
            body_params = params['cloud_account']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def update_cloud_job(self, cloud_job, cloud_job_id, **kwargs):
        """
        
        Modify a cloud job or operation.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_cloud_job(cloud_job, cloud_job_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param CloudJob cloud_job:  (required)
        :param str cloud_job_id: Modify a cloud job or operation. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_job', 'cloud_job_id']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_job' is set
        if ('cloud_job' not in params) or (params['cloud_job'] is None):
            raise ValueError("Missing the required parameter `cloud_job` when calling `update_cloud_job`")
        # verify the required parameter 'cloud_job_id' is set
        if ('cloud_job_id' not in params) or (params['cloud_job_id'] is None):
            raise ValueError("Missing the required parameter `cloud_job_id` when calling `update_cloud_job`")


        resource_path = '/platform/3/cloud/jobs/{CloudJobId}'.replace('{format}', 'json')
        path_params = {}
        if 'cloud_job_id' in params:
            path_params['CloudJobId'] = params['cloud_job_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'cloud_job' in params:
            body_params = params['cloud_job']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def update_cloud_pool(self, cloud_pool, cloud_pool_id, **kwargs):
        """
        
        Modify a cloud pool.  All fields are optional, but one or more must be supplied.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_cloud_pool(cloud_pool, cloud_pool_id, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param CloudPool cloud_pool:  (required)
        :param str cloud_pool_id: Modify a cloud pool.  All fields are optional, but one or more must be supplied. (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_pool', 'cloud_pool_id']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_pool' is set
        if ('cloud_pool' not in params) or (params['cloud_pool'] is None):
            raise ValueError("Missing the required parameter `cloud_pool` when calling `update_cloud_pool`")
        # verify the required parameter 'cloud_pool_id' is set
        if ('cloud_pool_id' not in params) or (params['cloud_pool_id'] is None):
            raise ValueError("Missing the required parameter `cloud_pool_id` when calling `update_cloud_pool`")


        resource_path = '/platform/3/cloud/pools/{CloudPoolId}'.replace('{format}', 'json')
        path_params = {}
        if 'cloud_pool_id' in params:
            path_params['CloudPoolId'] = params['cloud_pool_id']

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'cloud_pool' in params:
            body_params = params['cloud_pool']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response

    def update_cloud_settings(self, cloud_settings, **kwargs):
        """
        
        Modify one or more settings.

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please define a `callback` function
        to be invoked when receiving the response.
        >>> def callback_function(response):
        >>>     pprint(response)
        >>>
        >>> thread = api.update_cloud_settings(cloud_settings, callback=callback_function)

        :param callback function: The callback function
            for asynchronous request. (optional)
        :param CloudSettingsSettings cloud_settings:  (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ['cloud_settings']
        all_params.append('callback')

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

        # verify the required parameter 'cloud_settings' is set
        if ('cloud_settings' not in params) or (params['cloud_settings'] is None):
            raise ValueError("Missing the required parameter `cloud_settings` when calling `update_cloud_settings`")


        resource_path = '/platform/3/cloud/settings'.replace('{format}', 'json')
        path_params = {}

        query_params = {}

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'cloud_settings' in params:
            body_params = params['cloud_settings']

        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.\
            select_header_accept(['application/json'])
        if not header_params['Accept']:
            del header_params['Accept']

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.\
            select_header_content_type(['application/json'])

        # Authentication setting
        auth_settings = ['basic_auth']

        response = self.api_client.call_api(resource_path, 'PUT',
                                            path_params,
                                            query_params,
                                            header_params,
                                            body=body_params,
                                            post_params=form_params,
                                            files=local_var_files,
                                            response_type=None,
                                            auth_settings=auth_settings,
                                            callback=params.get('callback'))
        return response
