anyscale 0.26.17__py3-none-any.whl → 0.26.20__py3-none-any.whl

anyscale/client/openapi_client/api/default_api.py

@@ -895,120 +895,6 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def archive_cluster_api_v2_decorated_sessions_cluster_id_archive_post(self, cluster_id, **kwargs):  # noqa: E501
-        """Archive Cluster  # noqa: E501
-
-        Archives the cluster. It is a no-op if the cluster is already archived.  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.archive_cluster_api_v2_decorated_sessions_cluster_id_archive_post(cluster_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str cluster_id: (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: None
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.archive_cluster_api_v2_decorated_sessions_cluster_id_archive_post_with_http_info(cluster_id, **kwargs)  # noqa: E501
-
-    def archive_cluster_api_v2_decorated_sessions_cluster_id_archive_post_with_http_info(self, cluster_id, **kwargs):  # noqa: E501
-        """Archive Cluster  # noqa: E501
-
-        Archives the cluster. It is a no-op if the cluster is already archived.  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.archive_cluster_api_v2_decorated_sessions_cluster_id_archive_post_with_http_info(cluster_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str cluster_id: (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: None
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'cluster_id'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method archive_cluster_api_v2_decorated_sessions_cluster_id_archive_post" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'cluster_id' is set
-        if self.api_client.client_side_validation and ('cluster_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['cluster_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `cluster_id` when calling `archive_cluster_api_v2_decorated_sessions_cluster_id_archive_post`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'cluster_id' in local_var_params:
-            path_params['cluster_id'] = local_var_params['cluster_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'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/decorated_sessions/{cluster_id}/archive', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type=None,  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
     def archive_cluster_environment_api_v2_application_templates_application_template_id_archive_post(self, application_template_id, **kwargs):  # noqa: E501
         """Archive Cluster Environment  # noqa: E501
 
@@ -4524,124 +4410,6 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_connect_session_api_v2_sessions_create_connect_session_post(self, create_session_in_db, **kwargs):  # noqa: E501
-        """Create Connect Session  # noqa: E501
-
-        Creates a session for anyscale connect.  # 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_connect_session_api_v2_sessions_create_connect_session_post(create_session_in_db, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param CreateSessionInDb create_session_in_db: (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: SessionResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.create_connect_session_api_v2_sessions_create_connect_session_post_with_http_info(create_session_in_db, **kwargs)  # noqa: E501
-
-    def create_connect_session_api_v2_sessions_create_connect_session_post_with_http_info(self, create_session_in_db, **kwargs):  # noqa: E501
-        """Create Connect Session  # noqa: E501
-
-        Creates a session for anyscale connect.  # 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_connect_session_api_v2_sessions_create_connect_session_post_with_http_info(create_session_in_db, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param CreateSessionInDb create_session_in_db: (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: tuple(SessionResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'create_session_in_db'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method create_connect_session_api_v2_sessions_create_connect_session_post" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'create_session_in_db' is set
-        if self.api_client.client_side_validation and ('create_session_in_db' not in local_var_params or  # noqa: E501
-                                                        local_var_params['create_session_in_db'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `create_session_in_db` when calling `create_connect_session_api_v2_sessions_create_connect_session_post`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-
-        query_params = []
-
-        header_params = {}
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'create_session_in_db' in local_var_params:
-            body_params = local_var_params['create_session_in_db']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['application/json'])  # noqa: E501
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/sessions/create_connect_session', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='SessionResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
     def create_dataset_upload_api_v2_datasets_upload_post(self, create_dataset, **kwargs):  # noqa: E501
         """Create Dataset Upload  # noqa: E501
 
@@ -5464,122 +5232,6 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_new_session_api_v2_sessions_create_new_session_post(self, create_session_from_snapshot_options, **kwargs):  # noqa: E501
-        """Create New Session  # 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_new_session_api_v2_sessions_create_new_session_post(create_session_from_snapshot_options, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param CreateSessionFromSnapshotOptions create_session_from_snapshot_options: (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: CreatesessionresponseResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.create_new_session_api_v2_sessions_create_new_session_post_with_http_info(create_session_from_snapshot_options, **kwargs)  # noqa: E501
-
-    def create_new_session_api_v2_sessions_create_new_session_post_with_http_info(self, create_session_from_snapshot_options, **kwargs):  # noqa: E501
-        """Create New Session  # 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_new_session_api_v2_sessions_create_new_session_post_with_http_info(create_session_from_snapshot_options, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param CreateSessionFromSnapshotOptions create_session_from_snapshot_options: (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: tuple(CreatesessionresponseResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'create_session_from_snapshot_options'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method create_new_session_api_v2_sessions_create_new_session_post" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'create_session_from_snapshot_options' is set
-        if self.api_client.client_side_validation and ('create_session_from_snapshot_options' not in local_var_params or  # noqa: E501
-                                                        local_var_params['create_session_from_snapshot_options'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `create_session_from_snapshot_options` when calling `create_new_session_api_v2_sessions_create_new_session_post`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-
-        query_params = []
-
-        header_params = {}
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'create_session_from_snapshot_options' in local_var_params:
-            body_params = local_var_params['create_session_from_snapshot_options']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['application/json'])  # noqa: E501
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/sessions/create_new_session', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='CreatesessionresponseResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
     def create_one_time_password_api_v2_users_create_otp_token_get(self, **kwargs):  # noqa: E501
         """Create One Time Password  # noqa: E501
 
@@ -6870,124 +6522,6 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def create_workspace_from_job_api_v2_experimental_workspaces_from_job_post(self, create_experimental_workspace_from_job, **kwargs):  # noqa: E501
-        """Create Workspace From Job  # noqa: E501
-
-        Creates a Workspace from a 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_workspace_from_job_api_v2_experimental_workspaces_from_job_post(create_experimental_workspace_from_job, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param CreateExperimentalWorkspaceFromJob create_experimental_workspace_from_job: (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: ExperimentalworkspaceResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.create_workspace_from_job_api_v2_experimental_workspaces_from_job_post_with_http_info(create_experimental_workspace_from_job, **kwargs)  # noqa: E501
-
-    def create_workspace_from_job_api_v2_experimental_workspaces_from_job_post_with_http_info(self, create_experimental_workspace_from_job, **kwargs):  # noqa: E501
-        """Create Workspace From Job  # noqa: E501
-
-        Creates a Workspace from a 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_workspace_from_job_api_v2_experimental_workspaces_from_job_post_with_http_info(create_experimental_workspace_from_job, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param CreateExperimentalWorkspaceFromJob create_experimental_workspace_from_job: (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: tuple(ExperimentalworkspaceResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'create_experimental_workspace_from_job'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method create_workspace_from_job_api_v2_experimental_workspaces_from_job_post" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'create_experimental_workspace_from_job' is set
-        if self.api_client.client_side_validation and ('create_experimental_workspace_from_job' not in local_var_params or  # noqa: E501
-                                                        local_var_params['create_experimental_workspace_from_job'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `create_experimental_workspace_from_job` when calling `create_workspace_from_job_api_v2_experimental_workspaces_from_job_post`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-
-        query_params = []
-
-        header_params = {}
-
-        form_params = []
-        local_var_files = {}
-
-        body_params = None
-        if 'create_experimental_workspace_from_job' in local_var_params:
-            body_params = local_var_params['create_experimental_workspace_from_job']
-        # HTTP header `Accept`
-        header_params['Accept'] = self.api_client.select_header_accept(
-            ['application/json'])  # noqa: E501
-
-        # HTTP header `Content-Type`
-        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
-            ['application/json'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/experimental_workspaces/from_job', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='ExperimentalworkspaceResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
     def create_workspace_from_template_api_v2_experimental_workspaces_from_template_post(self, create_workspace_from_template, **kwargs):  # noqa: E501
         """Create Workspace From Template  # noqa: E501
 
@@ -8830,129 +8364,6 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_web_terminals_api_v2_sessions_session_id_web_terminals_terminal_id_delete(self, session_id, terminal_id, **kwargs):  # noqa: E501
-        """Delete Web Terminals  # noqa: E501
-
-        DEPRECATED: This API is no deprecated and will not be supported in Anyscale 2.0  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_web_terminals_api_v2_sessions_session_id_web_terminals_terminal_id_delete(session_id, terminal_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param str terminal_id: (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: None
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.delete_web_terminals_api_v2_sessions_session_id_web_terminals_terminal_id_delete_with_http_info(session_id, terminal_id, **kwargs)  # noqa: E501
-
-    def delete_web_terminals_api_v2_sessions_session_id_web_terminals_terminal_id_delete_with_http_info(self, session_id, terminal_id, **kwargs):  # noqa: E501
-        """Delete Web Terminals  # noqa: E501
-
-        DEPRECATED: This API is no deprecated and will not be supported in Anyscale 2.0  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.delete_web_terminals_api_v2_sessions_session_id_web_terminals_terminal_id_delete_with_http_info(session_id, terminal_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param str terminal_id: (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: None
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'session_id',
-            'terminal_id'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method delete_web_terminals_api_v2_sessions_session_id_web_terminals_terminal_id_delete" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'session_id' is set
-        if self.api_client.client_side_validation and ('session_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['session_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_id` when calling `delete_web_terminals_api_v2_sessions_session_id_web_terminals_terminal_id_delete`")  # noqa: E501
-        # verify the required parameter 'terminal_id' is set
-        if self.api_client.client_side_validation and ('terminal_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['terminal_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `terminal_id` when calling `delete_web_terminals_api_v2_sessions_session_id_web_terminals_terminal_id_delete`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'session_id' in local_var_params:
-            path_params['session_id'] = local_var_params['session_id']  # noqa: E501
-        if 'terminal_id' in local_var_params:
-            path_params['terminal_id'] = local_var_params['terminal_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'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/sessions/{session_id}/web_terminals/{terminal_id}', 'DELETE',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type=None,  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
     def delete_workspace_api_v2_experimental_workspaces_workspace_id_delete(self, workspace_id, **kwargs):  # noqa: E501
         """Delete Workspace  # noqa: E501
 
@@ -9185,118 +8596,6 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def describe_session_api_v2_sessions_session_id_describe_get(self, session_id, **kwargs):  # noqa: E501
-        """Describe Session  # noqa: E501
-
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_session_api_v2_sessions_session_id_describe_get(session_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: SessiondescribeResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.describe_session_api_v2_sessions_session_id_describe_get_with_http_info(session_id, **kwargs)  # noqa: E501
-
-    def describe_session_api_v2_sessions_session_id_describe_get_with_http_info(self, session_id, **kwargs):  # noqa: E501
-        """Describe Session  # noqa: E501
-
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.describe_session_api_v2_sessions_session_id_describe_get_with_http_info(session_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: tuple(SessiondescribeResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'session_id'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method describe_session_api_v2_sessions_session_id_describe_get" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'session_id' is set
-        if self.api_client.client_side_validation and ('session_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['session_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_id` when calling `describe_session_api_v2_sessions_session_id_describe_get`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'session_id' in local_var_params:
-            path_params['session_id'] = local_var_params['session_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'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/sessions/{session_id}/describe', 'GET',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='SessiondescribeResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
     def describe_system_workload_api_v2_system_workload_cloud_id_describe_post(self, cloud_id, workload_name, **kwargs):  # noqa: E501
         """Describe System Workload  # noqa: E501
 
@@ -12926,6 +12225,118 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def get_cloud_deployments_api_v2_clouds_cloud_id_deployments_get(self, cloud_id, **kwargs):  # noqa: E501
+        """Get Cloud Deployments  # 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_cloud_deployments_api_v2_clouds_cloud_id_deployments_get(cloud_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str cloud_id: (required)
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: ClouddeploymentListResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.get_cloud_deployments_api_v2_clouds_cloud_id_deployments_get_with_http_info(cloud_id, **kwargs)  # noqa: E501
+
+    def get_cloud_deployments_api_v2_clouds_cloud_id_deployments_get_with_http_info(self, cloud_id, **kwargs):  # noqa: E501
+        """Get Cloud Deployments  # 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_cloud_deployments_api_v2_clouds_cloud_id_deployments_get_with_http_info(cloud_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str cloud_id: (required)
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: tuple(ClouddeploymentListResponse, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'cloud_id'
+        ]
+        all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout'
+            ]
+        )
+
+        for key, val in six.iteritems(local_var_params['kwargs']):
+            if key not in all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_cloud_deployments_api_v2_clouds_cloud_id_deployments_get" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'cloud_id' is set
+        if self.api_client.client_side_validation and ('cloud_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['cloud_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `cloud_id` when calling `get_cloud_deployments_api_v2_clouds_cloud_id_deployments_get`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'cloud_id' in local_var_params:
+            path_params['cloud_id'] = local_var_params['cloud_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'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = []  # noqa: E501
+
+        return self.api_client.call_api(
+            '/api/v2/clouds/{cloud_id}/deployments', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ClouddeploymentListResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=local_var_params.get('async_req'),
+            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=local_var_params.get('_preload_content', True),
+            _request_timeout=local_var_params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def get_cloud_overview_dashboard_api_v2_clouds_cloud_id_cloud_overview_dashboard_get(self, cloud_id, **kwargs):  # noqa: E501
         """Get Cloud Overview Dashboard  # noqa: E501
 
@@ -15877,258 +15288,6 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_execution_logs_api_v2_session_commands_session_command_id_execution_logs_get(self, session_command_id, start_line, end_line, **kwargs):  # noqa: E501
-        """Get Execution Logs  # 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_execution_logs_api_v2_session_commands_session_command_id_execution_logs_get(session_command_id, start_line, end_line, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_command_id: (required)
-        :param int start_line: (required)
-        :param int end_line: (required)
-        :param str extension:
-        :param datetime start_time:
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: LogsoutputResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.get_execution_logs_api_v2_session_commands_session_command_id_execution_logs_get_with_http_info(session_command_id, start_line, end_line, **kwargs)  # noqa: E501
-
-    def get_execution_logs_api_v2_session_commands_session_command_id_execution_logs_get_with_http_info(self, session_command_id, start_line, end_line, **kwargs):  # noqa: E501
-        """Get Execution Logs  # 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_execution_logs_api_v2_session_commands_session_command_id_execution_logs_get_with_http_info(session_command_id, start_line, end_line, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_command_id: (required)
-        :param int start_line: (required)
-        :param int end_line: (required)
-        :param str extension:
-        :param datetime start_time:
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: tuple(LogsoutputResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'session_command_id',
-            'start_line',
-            'end_line',
-            'extension',
-            'start_time'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method get_execution_logs_api_v2_session_commands_session_command_id_execution_logs_get" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'session_command_id' is set
-        if self.api_client.client_side_validation and ('session_command_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['session_command_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_command_id` when calling `get_execution_logs_api_v2_session_commands_session_command_id_execution_logs_get`")  # noqa: E501
-        # verify the required parameter 'start_line' is set
-        if self.api_client.client_side_validation and ('start_line' not in local_var_params or  # noqa: E501
-                                                        local_var_params['start_line'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `start_line` when calling `get_execution_logs_api_v2_session_commands_session_command_id_execution_logs_get`")  # noqa: E501
-        # verify the required parameter 'end_line' is set
-        if self.api_client.client_side_validation and ('end_line' not in local_var_params or  # noqa: E501
-                                                        local_var_params['end_line'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `end_line` when calling `get_execution_logs_api_v2_session_commands_session_command_id_execution_logs_get`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'session_command_id' in local_var_params:
-            path_params['session_command_id'] = local_var_params['session_command_id']  # noqa: E501
-
-        query_params = []
-        if 'start_line' in local_var_params and local_var_params['start_line'] is not None:  # noqa: E501
-            query_params.append(('start_line', local_var_params['start_line']))  # noqa: E501
-        if 'end_line' in local_var_params and local_var_params['end_line'] is not None:  # noqa: E501
-            query_params.append(('end_line', local_var_params['end_line']))  # noqa: E501
-        if 'extension' in local_var_params and local_var_params['extension'] is not None:  # noqa: E501
-            query_params.append(('extension', local_var_params['extension']))  # noqa: E501
-        if 'start_time' in local_var_params and local_var_params['start_time'] is not None:  # noqa: E501
-            query_params.append(('start_time', local_var_params['start_time']))  # 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'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/session_commands/{session_command_id}/execution_logs', 'GET',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='LogsoutputResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
-    def get_execution_logs_archived_api_v2_session_commands_session_command_id_execution_logs_archived_get(self, session_command_id, **kwargs):  # noqa: E501
-        """Get Execution Logs Archived  # 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_execution_logs_archived_api_v2_session_commands_session_command_id_execution_logs_archived_get(session_command_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_command_id: (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: ArchivedlogsinfoResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.get_execution_logs_archived_api_v2_session_commands_session_command_id_execution_logs_archived_get_with_http_info(session_command_id, **kwargs)  # noqa: E501
-
-    def get_execution_logs_archived_api_v2_session_commands_session_command_id_execution_logs_archived_get_with_http_info(self, session_command_id, **kwargs):  # noqa: E501
-        """Get Execution Logs Archived  # 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_execution_logs_archived_api_v2_session_commands_session_command_id_execution_logs_archived_get_with_http_info(session_command_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_command_id: (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: tuple(ArchivedlogsinfoResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'session_command_id'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method get_execution_logs_archived_api_v2_session_commands_session_command_id_execution_logs_archived_get" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'session_command_id' is set
-        if self.api_client.client_side_validation and ('session_command_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['session_command_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_command_id` when calling `get_execution_logs_archived_api_v2_session_commands_session_command_id_execution_logs_archived_get`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'session_command_id' in local_var_params:
-            path_params['session_command_id'] = local_var_params['session_command_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'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/session_commands/{session_command_id}/execution_logs_archived', 'GET',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='ArchivedlogsinfoResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
     def get_instance_usage_budget_api_v2_instance_usage_budgets_instance_usage_budget_id_get(self, instance_usage_budget_id, **kwargs):  # noqa: E501
         """Get Instance Usage Budget  # noqa: E501
 
@@ -18231,235 +17390,6 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_monitor_logs_archived_api_v2_sessions_session_id_monitor_logs_archived_get(self, session_id, **kwargs):  # noqa: E501
-        """Get Monitor Logs Archived  # 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_monitor_logs_archived_api_v2_sessions_session_id_monitor_logs_archived_get(session_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: ArchivedlogsinfoResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.get_monitor_logs_archived_api_v2_sessions_session_id_monitor_logs_archived_get_with_http_info(session_id, **kwargs)  # noqa: E501
-
-    def get_monitor_logs_archived_api_v2_sessions_session_id_monitor_logs_archived_get_with_http_info(self, session_id, **kwargs):  # noqa: E501
-        """Get Monitor Logs Archived  # 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_monitor_logs_archived_api_v2_sessions_session_id_monitor_logs_archived_get_with_http_info(session_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: tuple(ArchivedlogsinfoResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'session_id'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method get_monitor_logs_archived_api_v2_sessions_session_id_monitor_logs_archived_get" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'session_id' is set
-        if self.api_client.client_side_validation and ('session_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['session_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_id` when calling `get_monitor_logs_archived_api_v2_sessions_session_id_monitor_logs_archived_get`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'session_id' in local_var_params:
-            path_params['session_id'] = local_var_params['session_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'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/sessions/{session_id}/monitor_logs_archived', 'GET',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='ArchivedlogsinfoResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
-    def get_monitor_logs_download_api_v2_logs_monitor_logs_download_session_id_get(self, session_id, **kwargs):  # noqa: E501
-        """Get Monitor Logs Download  # 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_monitor_logs_download_api_v2_logs_monitor_logs_download_session_id_get(session_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param MonitorLogsExtension extension: Extension of monitor logs to return. Defaults to .log, which is for autoscaler status
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: LogdownloadresultResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.get_monitor_logs_download_api_v2_logs_monitor_logs_download_session_id_get_with_http_info(session_id, **kwargs)  # noqa: E501
-
-    def get_monitor_logs_download_api_v2_logs_monitor_logs_download_session_id_get_with_http_info(self, session_id, **kwargs):  # noqa: E501
-        """Get Monitor Logs Download  # 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_monitor_logs_download_api_v2_logs_monitor_logs_download_session_id_get_with_http_info(session_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param MonitorLogsExtension extension: Extension of monitor logs to return. Defaults to .log, which is for autoscaler status
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: tuple(LogdownloadresultResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'session_id',
-            'extension'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method get_monitor_logs_download_api_v2_logs_monitor_logs_download_session_id_get" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'session_id' is set
-        if self.api_client.client_side_validation and ('session_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['session_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_id` when calling `get_monitor_logs_download_api_v2_logs_monitor_logs_download_session_id_get`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'session_id' in local_var_params:
-            path_params['session_id'] = local_var_params['session_id']  # noqa: E501
-
-        query_params = []
-        if 'extension' in local_var_params and local_var_params['extension'] is not None:  # noqa: E501
-            query_params.append(('extension', local_var_params['extension']))  # 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'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/logs/monitor_logs_download/{session_id}', 'GET',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='LogdownloadresultResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
     def get_operator_metrics_api_v2_dataset_runs_operator_get(self, cluster_id, session_name, dataset_id, operator_id, dataset_start_time, dataset_end_time, **kwargs):  # noqa: E501
         """Get Operator Metrics  # noqa: E501
 
@@ -18722,120 +17652,6 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_ping_external_services_api_v2_sessions_session_id_ping_external_services_get(self, session_id, **kwargs):  # noqa: E501
-        """Get Ping External Services  # noqa: E501
-
-        Ping external session services to see if SSL negotiations have completed. SSL errors will throw URLErrors and will not have a status code. Using this endpoint is preferred over directly pinging these services on the web client because CORS is restricted.  # 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_ping_external_services_api_v2_sessions_session_id_ping_external_services_get(session_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: ExternalservicestatusresponseResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.get_ping_external_services_api_v2_sessions_session_id_ping_external_services_get_with_http_info(session_id, **kwargs)  # noqa: E501
-
-    def get_ping_external_services_api_v2_sessions_session_id_ping_external_services_get_with_http_info(self, session_id, **kwargs):  # noqa: E501
-        """Get Ping External Services  # noqa: E501
-
-        Ping external session services to see if SSL negotiations have completed. SSL errors will throw URLErrors and will not have a status code. Using this endpoint is preferred over directly pinging these services on the web client because CORS is restricted.  # 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_ping_external_services_api_v2_sessions_session_id_ping_external_services_get_with_http_info(session_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: tuple(ExternalservicestatusresponseResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'session_id'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method get_ping_external_services_api_v2_sessions_session_id_ping_external_services_get" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'session_id' is set
-        if self.api_client.client_side_validation and ('session_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['session_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_id` when calling `get_ping_external_services_api_v2_sessions_session_id_ping_external_services_get`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'session_id' in local_var_params:
-            path_params['session_id'] = local_var_params['session_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'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/sessions/{session_id}/ping_external_services', 'GET',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='ExternalservicestatusresponseResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
     def get_project_api_v2_projects_project_id_get(self, project_id, **kwargs):  # noqa: E501
         """Get Project  # noqa: E501
 
@@ -19936,16 +18752,16 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_root_cause_api_v2_iknow_get(self, cluster_id, **kwargs):  # noqa: E501
-        """Get Root Cause  # noqa: E501
+    def get_root_cause_for_job_api_v2_iknow_get(self, ha_job_id, **kwargs):  # noqa: E501
+        """Get Root Cause For 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_root_cause_api_v2_iknow_get(cluster_id, async_req=True)
+        >>> thread = api.get_root_cause_for_job_api_v2_iknow_get(ha_job_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str cluster_id: (required)
+        :param str ha_job_id: (required)
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -19958,18 +18774,18 @@ class DefaultApi(object):
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.get_root_cause_api_v2_iknow_get_with_http_info(cluster_id, **kwargs)  # noqa: E501
+        return self.get_root_cause_for_job_api_v2_iknow_get_with_http_info(ha_job_id, **kwargs)  # noqa: E501
 
-    def get_root_cause_api_v2_iknow_get_with_http_info(self, cluster_id, **kwargs):  # noqa: E501
-        """Get Root Cause  # noqa: E501
+    def get_root_cause_for_job_api_v2_iknow_get_with_http_info(self, ha_job_id, **kwargs):  # noqa: E501
+        """Get Root Cause For 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_root_cause_api_v2_iknow_get_with_http_info(cluster_id, async_req=True)
+        >>> thread = api.get_root_cause_for_job_api_v2_iknow_get_with_http_info(ha_job_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str cluster_id: (required)
+        :param str ha_job_id: (required)
         :param _return_http_data_only: response data without head status code
                                        and headers
         :param _preload_content: if False, the urllib3.HTTPResponse object will
@@ -19987,7 +18803,7 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'cluster_id'
+            'ha_job_id'
         ]
         all_params.extend(
             [
@@ -20002,22 +18818,22 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_root_cause_api_v2_iknow_get" % key
+                    " to method get_root_cause_for_job_api_v2_iknow_get" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
-        # verify the required parameter 'cluster_id' is set
-        if self.api_client.client_side_validation and ('cluster_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['cluster_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `cluster_id` when calling `get_root_cause_api_v2_iknow_get`")  # noqa: E501
+        # verify the required parameter 'ha_job_id' is set
+        if self.api_client.client_side_validation and ('ha_job_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['ha_job_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `ha_job_id` when calling `get_root_cause_for_job_api_v2_iknow_get`")  # noqa: E501
 
         collection_formats = {}
 
         path_params = {}
 
         query_params = []
-        if 'cluster_id' in local_var_params and local_var_params['cluster_id'] is not None:  # noqa: E501
-            query_params.append(('cluster_id', local_var_params['cluster_id']))  # noqa: E501
+        if 'ha_job_id' in local_var_params and local_var_params['ha_job_id'] is not None:  # noqa: E501
+            query_params.append(('ha_job_id', local_var_params['ha_job_id']))  # noqa: E501
 
         header_params = {}
 
@@ -20903,385 +19719,14 @@ class DefaultApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/api/v2/sessions/{session_id}', 'GET',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='SessionResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
-    def get_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get(self, session_id, session_command_id, **kwargs):  # noqa: E501
-        """Get Session Command Logs Download  # 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_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get(session_id, session_command_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param str session_command_id: (required)
-        :param bool use_bearer_token: Whether to use the more performant bearer-token based log downloading for GCP. Defaults to false for backwards compatibility.
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: LogdownloadresultResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.get_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get_with_http_info(session_id, session_command_id, **kwargs)  # noqa: E501
-
-    def get_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get_with_http_info(self, session_id, session_command_id, **kwargs):  # noqa: E501
-        """Get Session Command Logs Download  # 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_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get_with_http_info(session_id, session_command_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param str session_command_id: (required)
-        :param bool use_bearer_token: Whether to use the more performant bearer-token based log downloading for GCP. Defaults to false for backwards compatibility.
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: tuple(LogdownloadresultResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'session_id',
-            'session_command_id',
-            'use_bearer_token'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method get_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'session_id' is set
-        if self.api_client.client_side_validation and ('session_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['session_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_id` when calling `get_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get`")  # noqa: E501
-        # verify the required parameter 'session_command_id' is set
-        if self.api_client.client_side_validation and ('session_command_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['session_command_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_command_id` when calling `get_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'session_id' in local_var_params:
-            path_params['session_id'] = local_var_params['session_id']  # noqa: E501
-        if 'session_command_id' in local_var_params:
-            path_params['session_command_id'] = local_var_params['session_command_id']  # noqa: E501
-
-        query_params = []
-        if 'use_bearer_token' in local_var_params and local_var_params['use_bearer_token'] is not None:  # noqa: E501
-            query_params.append(('use_bearer_token', local_var_params['use_bearer_token']))  # 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'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/logs/session_command_logs/{session_id}/{session_command_id}', 'GET',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='LogdownloadresultResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
-    def get_session_commands_history_api_v2_session_commands_get(self, session_id, **kwargs):  # noqa: E501
-        """Get Session Commands History  # noqa: E501
-
-        List all commands that have been run on a session.  # 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_session_commands_history_api_v2_session_commands_get(session_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param str shell_command: shell command to filter by
-        :param str paging_token:
-        :param int count:
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: SessioncommandListResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.get_session_commands_history_api_v2_session_commands_get_with_http_info(session_id, **kwargs)  # noqa: E501
-
-    def get_session_commands_history_api_v2_session_commands_get_with_http_info(self, session_id, **kwargs):  # noqa: E501
-        """Get Session Commands History  # noqa: E501
-
-        List all commands that have been run on a session.  # 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_session_commands_history_api_v2_session_commands_get_with_http_info(session_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param str shell_command: shell command to filter by
-        :param str paging_token:
-        :param int count:
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: tuple(SessioncommandListResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'session_id',
-            'shell_command',
-            'paging_token',
-            'count'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method get_session_commands_history_api_v2_session_commands_get" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'session_id' is set
-        if self.api_client.client_side_validation and ('session_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['session_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_id` when calling `get_session_commands_history_api_v2_session_commands_get`")  # noqa: E501
-
-        if self.api_client.client_side_validation and 'count' in local_var_params and local_var_params['count'] > 50:  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `count` when calling `get_session_commands_history_api_v2_session_commands_get`, must be a value less than or equal to `50`")  # noqa: E501
-        if self.api_client.client_side_validation and 'count' in local_var_params and local_var_params['count'] < 0:  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `count` when calling `get_session_commands_history_api_v2_session_commands_get`, must be a value greater than or equal to `0`")  # noqa: E501
-        collection_formats = {}
-
-        path_params = {}
-
-        query_params = []
-        if 'session_id' in local_var_params and local_var_params['session_id'] is not None:  # noqa: E501
-            query_params.append(('session_id', local_var_params['session_id']))  # noqa: E501
-        if 'shell_command' in local_var_params and local_var_params['shell_command'] is not None:  # noqa: E501
-            query_params.append(('shell_command', local_var_params['shell_command']))  # noqa: E501
-        if 'paging_token' in local_var_params and local_var_params['paging_token'] is not None:  # noqa: E501
-            query_params.append(('paging_token', local_var_params['paging_token']))  # noqa: E501
-        if 'count' in local_var_params and local_var_params['count'] is not None:  # noqa: E501
-            query_params.append(('count', local_var_params['count']))  # 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'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/session_commands/', 'GET',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='SessioncommandListResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
-    def get_session_details_api_v2_sessions_session_id_details_get(self, session_id, **kwargs):  # noqa: E501
-        """Get Session Details  # noqa: E501
-
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_session_details_api_v2_sessions_session_id_details_get(session_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: SessiondetailsResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.get_session_details_api_v2_sessions_session_id_details_get_with_http_info(session_id, **kwargs)  # noqa: E501
-
-    def get_session_details_api_v2_sessions_session_id_details_get_with_http_info(self, session_id, **kwargs):  # noqa: E501
-        """Get Session Details  # noqa: E501
-
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.get_session_details_api_v2_sessions_session_id_details_get_with_http_info(session_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: tuple(SessiondetailsResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'session_id'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method get_session_details_api_v2_sessions_session_id_details_get" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'session_id' is set
-        if self.api_client.client_side_validation and ('session_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['session_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_id` when calling `get_session_details_api_v2_sessions_session_id_details_get`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'session_id' in local_var_params:
-            path_params['session_id'] = local_var_params['session_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'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/sessions/{session_id}/details', 'GET',
+            '/api/v2/sessions/{session_id}', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='SessiondetailsResponse',  # noqa: E501
+            response_type='SessionResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=local_var_params.get('async_req'),
             _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
@@ -21289,17 +19734,18 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_session_head_ip_api_v2_sessions_session_id_head_ip_get(self, session_id, **kwargs):  # noqa: E501
-        """Get Session Head Ip  # noqa: E501
+    def get_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get(self, session_id, session_command_id, **kwargs):  # noqa: E501
+        """Get Session Command Logs Download  # noqa: E501
 
-        Fetches the ip of the head node of the session.  # 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_session_head_ip_api_v2_sessions_session_id_head_ip_get(session_id, async_req=True)
+        >>> thread = api.get_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get(session_id, session_command_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
         :param str session_id: (required)
+        :param str session_command_id: (required)
+        :param bool use_bearer_token: Whether to use the more performant bearer-token based log downloading for GCP. Defaults to false for backwards compatibility.
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -21307,24 +19753,25 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: HeadipResponse
+        :return: LogdownloadresultResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.get_session_head_ip_api_v2_sessions_session_id_head_ip_get_with_http_info(session_id, **kwargs)  # noqa: E501
+        return self.get_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get_with_http_info(session_id, session_command_id, **kwargs)  # noqa: E501
 
-    def get_session_head_ip_api_v2_sessions_session_id_head_ip_get_with_http_info(self, session_id, **kwargs):  # noqa: E501
-        """Get Session Head Ip  # noqa: E501
+    def get_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get_with_http_info(self, session_id, session_command_id, **kwargs):  # noqa: E501
+        """Get Session Command Logs Download  # noqa: E501
 
-        Fetches the ip of the head node of the session.  # 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_session_head_ip_api_v2_sessions_session_id_head_ip_get_with_http_info(session_id, async_req=True)
+        >>> thread = api.get_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get_with_http_info(session_id, session_command_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
         :param str session_id: (required)
+        :param str session_command_id: (required)
+        :param bool use_bearer_token: Whether to use the more performant bearer-token based log downloading for GCP. Defaults to false for backwards compatibility.
         :param _return_http_data_only: response data without head status code
                                        and headers
         :param _preload_content: if False, the urllib3.HTTPResponse object will
@@ -21334,7 +19781,7 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: tuple(HeadipResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(LogdownloadresultResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -21342,7 +19789,9 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'session_id'
+            'session_id',
+            'session_command_id',
+            'use_bearer_token'
         ]
         all_params.extend(
             [
@@ -21357,22 +19806,30 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_session_head_ip_api_v2_sessions_session_id_head_ip_get" % key
+                    " to method get_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
         # verify the required parameter 'session_id' is set
         if self.api_client.client_side_validation and ('session_id' not in local_var_params or  # noqa: E501
                                                         local_var_params['session_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_id` when calling `get_session_head_ip_api_v2_sessions_session_id_head_ip_get`")  # noqa: E501
+            raise ApiValueError("Missing the required parameter `session_id` when calling `get_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get`")  # noqa: E501
+        # verify the required parameter 'session_command_id' is set
+        if self.api_client.client_side_validation and ('session_command_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['session_command_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `session_command_id` when calling `get_session_command_logs_download_api_v2_logs_session_command_logs_session_id_session_command_id_get`")  # noqa: E501
 
         collection_formats = {}
 
         path_params = {}
         if 'session_id' in local_var_params:
             path_params['session_id'] = local_var_params['session_id']  # noqa: E501
+        if 'session_command_id' in local_var_params:
+            path_params['session_command_id'] = local_var_params['session_command_id']  # noqa: E501
 
         query_params = []
+        if 'use_bearer_token' in local_var_params and local_var_params['use_bearer_token'] is not None:  # noqa: E501
+            query_params.append(('use_bearer_token', local_var_params['use_bearer_token']))  # noqa: E501
 
         header_params = {}
 
@@ -21388,14 +19845,14 @@ class DefaultApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/api/v2/sessions/{session_id}/head_ip', 'GET',
+            '/api/v2/logs/session_command_logs/{session_id}/{session_command_id}', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='HeadipResponse',  # noqa: E501
+            response_type='LogdownloadresultResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=local_var_params.get('async_req'),
             _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
@@ -21403,17 +19860,18 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_session_history_api_v2_sessions_session_id_history_get(self, session_id, **kwargs):  # noqa: E501
-        """Get Session History  # noqa: E501
+    def get_session_commands_history_api_v2_session_commands_get(self, session_id, **kwargs):  # noqa: E501
+        """Get Session Commands History  # noqa: E501
 
-        Describe all actions applied to a particular session.  # noqa: E501
+        List all commands that have been run on a session.  # 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_session_history_api_v2_sessions_session_id_history_get(session_id, async_req=True)
+        >>> thread = api.get_session_commands_history_api_v2_session_commands_get(session_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
         :param str session_id: (required)
+        :param str shell_command: shell command to filter by
         :param str paging_token:
         :param int count:
         :param _preload_content: if False, the urllib3.HTTPResponse object will
@@ -21423,24 +19881,25 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: SessionhistoryitemListResponse
+        :return: SessioncommandListResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.get_session_history_api_v2_sessions_session_id_history_get_with_http_info(session_id, **kwargs)  # noqa: E501
+        return self.get_session_commands_history_api_v2_session_commands_get_with_http_info(session_id, **kwargs)  # noqa: E501
 
-    def get_session_history_api_v2_sessions_session_id_history_get_with_http_info(self, session_id, **kwargs):  # noqa: E501
-        """Get Session History  # noqa: E501
+    def get_session_commands_history_api_v2_session_commands_get_with_http_info(self, session_id, **kwargs):  # noqa: E501
+        """Get Session Commands History  # noqa: E501
 
-        Describe all actions applied to a particular session.  # noqa: E501
+        List all commands that have been run on a session.  # 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_session_history_api_v2_sessions_session_id_history_get_with_http_info(session_id, async_req=True)
+        >>> thread = api.get_session_commands_history_api_v2_session_commands_get_with_http_info(session_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
         :param str session_id: (required)
+        :param str shell_command: shell command to filter by
         :param str paging_token:
         :param int count:
         :param _return_http_data_only: response data without head status code
@@ -21452,7 +19911,7 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: tuple(SessionhistoryitemListResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(SessioncommandListResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -21461,6 +19920,7 @@ class DefaultApi(object):
 
         all_params = [
             'session_id',
+            'shell_command',
             'paging_token',
             'count'
         ]
@@ -21477,26 +19937,28 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_session_history_api_v2_sessions_session_id_history_get" % key
+                    " to method get_session_commands_history_api_v2_session_commands_get" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
         # verify the required parameter 'session_id' is set
         if self.api_client.client_side_validation and ('session_id' not in local_var_params or  # noqa: E501
                                                         local_var_params['session_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_id` when calling `get_session_history_api_v2_sessions_session_id_history_get`")  # noqa: E501
+            raise ApiValueError("Missing the required parameter `session_id` when calling `get_session_commands_history_api_v2_session_commands_get`")  # noqa: E501
 
         if self.api_client.client_side_validation and 'count' in local_var_params and local_var_params['count'] > 50:  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `count` when calling `get_session_history_api_v2_sessions_session_id_history_get`, must be a value less than or equal to `50`")  # noqa: E501
+            raise ApiValueError("Invalid value for parameter `count` when calling `get_session_commands_history_api_v2_session_commands_get`, must be a value less than or equal to `50`")  # noqa: E501
         if self.api_client.client_side_validation and 'count' in local_var_params and local_var_params['count'] < 0:  # noqa: E501
-            raise ApiValueError("Invalid value for parameter `count` when calling `get_session_history_api_v2_sessions_session_id_history_get`, must be a value greater than or equal to `0`")  # noqa: E501
+            raise ApiValueError("Invalid value for parameter `count` when calling `get_session_commands_history_api_v2_session_commands_get`, must be a value greater than or equal to `0`")  # noqa: E501
         collection_formats = {}
 
         path_params = {}
-        if 'session_id' in local_var_params:
-            path_params['session_id'] = local_var_params['session_id']  # noqa: E501
 
         query_params = []
+        if 'session_id' in local_var_params and local_var_params['session_id'] is not None:  # noqa: E501
+            query_params.append(('session_id', local_var_params['session_id']))  # noqa: E501
+        if 'shell_command' in local_var_params and local_var_params['shell_command'] is not None:  # noqa: E501
+            query_params.append(('shell_command', local_var_params['shell_command']))  # noqa: E501
         if 'paging_token' in local_var_params and local_var_params['paging_token'] is not None:  # noqa: E501
             query_params.append(('paging_token', local_var_params['paging_token']))  # noqa: E501
         if 'count' in local_var_params and local_var_params['count'] is not None:  # noqa: E501
@@ -21516,14 +19978,14 @@ class DefaultApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/api/v2/sessions/{session_id}/history', 'GET',
+            '/api/v2/session_commands/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='SessionhistoryitemListResponse',  # noqa: E501
+            response_type='SessioncommandListResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=local_var_params.get('async_req'),
             _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
@@ -21531,13 +19993,13 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_session_ssh_key_api_v2_sessions_session_id_ssh_key_get(self, session_id, **kwargs):  # noqa: E501
-        """Get Session Ssh Key  # noqa: E501
+    def get_session_head_ip_api_v2_sessions_session_id_head_ip_get(self, session_id, **kwargs):  # noqa: E501
+        """Get Session Head Ip  # noqa: E501
 
-        Download SSH needed to log into a given session.  # noqa: E501
+        Fetches the ip of the head node of the session.  # 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_session_ssh_key_api_v2_sessions_session_id_ssh_key_get(session_id, async_req=True)
+        >>> thread = api.get_session_head_ip_api_v2_sessions_session_id_head_ip_get(session_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
@@ -21549,20 +20011,20 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: SessionsshkeyResponse
+        :return: HeadipResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.get_session_ssh_key_api_v2_sessions_session_id_ssh_key_get_with_http_info(session_id, **kwargs)  # noqa: E501
+        return self.get_session_head_ip_api_v2_sessions_session_id_head_ip_get_with_http_info(session_id, **kwargs)  # noqa: E501
 
-    def get_session_ssh_key_api_v2_sessions_session_id_ssh_key_get_with_http_info(self, session_id, **kwargs):  # noqa: E501
-        """Get Session Ssh Key  # noqa: E501
+    def get_session_head_ip_api_v2_sessions_session_id_head_ip_get_with_http_info(self, session_id, **kwargs):  # noqa: E501
+        """Get Session Head Ip  # noqa: E501
 
-        Download SSH needed to log into a given session.  # noqa: E501
+        Fetches the ip of the head node of the session.  # 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_session_ssh_key_api_v2_sessions_session_id_ssh_key_get_with_http_info(session_id, async_req=True)
+        >>> thread = api.get_session_head_ip_api_v2_sessions_session_id_head_ip_get_with_http_info(session_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
@@ -21576,7 +20038,7 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: tuple(SessionsshkeyResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(HeadipResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -21599,14 +20061,14 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_session_ssh_key_api_v2_sessions_session_id_ssh_key_get" % key
+                    " to method get_session_head_ip_api_v2_sessions_session_id_head_ip_get" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
         # verify the required parameter 'session_id' is set
         if self.api_client.client_side_validation and ('session_id' not in local_var_params or  # noqa: E501
                                                         local_var_params['session_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_id` when calling `get_session_ssh_key_api_v2_sessions_session_id_ssh_key_get`")  # noqa: E501
+            raise ApiValueError("Missing the required parameter `session_id` when calling `get_session_head_ip_api_v2_sessions_session_id_head_ip_get`")  # noqa: E501
 
         collection_formats = {}
 
@@ -21630,14 +20092,14 @@ class DefaultApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/api/v2/sessions/{session_id}/ssh_key', 'GET',
+            '/api/v2/sessions/{session_id}/head_ip', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='SessionsshkeyResponse',  # noqa: E501
+            response_type='HeadipResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=local_var_params.get('async_req'),
             _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
@@ -21645,20 +20107,17 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_startup_logs_api_v2_sessions_session_id_startup_logs_get(self, session_id, start_line, end_line, **kwargs):  # noqa: E501
-        """Get Startup Logs  # noqa: E501
+    def get_session_ssh_key_api_v2_sessions_session_id_ssh_key_get(self, session_id, **kwargs):  # noqa: E501
+        """Get Session Ssh Key  # noqa: E501
 
+        Download SSH needed to log into a given session.  # 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_startup_logs_api_v2_sessions_session_id_startup_logs_get(session_id, start_line, end_line, async_req=True)
+        >>> thread = api.get_session_ssh_key_api_v2_sessions_session_id_ssh_key_get(session_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
         :param str session_id: (required)
-        :param int start_line: (required)
-        :param int end_line: (required)
-        :param str extension:
-        :param datetime start_time:
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -21666,27 +20125,24 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: LogsoutputResponse
+        :return: SessionsshkeyResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.get_startup_logs_api_v2_sessions_session_id_startup_logs_get_with_http_info(session_id, start_line, end_line, **kwargs)  # noqa: E501
+        return self.get_session_ssh_key_api_v2_sessions_session_id_ssh_key_get_with_http_info(session_id, **kwargs)  # noqa: E501
 
-    def get_startup_logs_api_v2_sessions_session_id_startup_logs_get_with_http_info(self, session_id, start_line, end_line, **kwargs):  # noqa: E501
-        """Get Startup Logs  # noqa: E501
+    def get_session_ssh_key_api_v2_sessions_session_id_ssh_key_get_with_http_info(self, session_id, **kwargs):  # noqa: E501
+        """Get Session Ssh Key  # noqa: E501
 
+        Download SSH needed to log into a given session.  # 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_startup_logs_api_v2_sessions_session_id_startup_logs_get_with_http_info(session_id, start_line, end_line, async_req=True)
+        >>> thread = api.get_session_ssh_key_api_v2_sessions_session_id_ssh_key_get_with_http_info(session_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
         :param str session_id: (required)
-        :param int start_line: (required)
-        :param int end_line: (required)
-        :param str extension:
-        :param datetime start_time:
         :param _return_http_data_only: response data without head status code
                                        and headers
         :param _preload_content: if False, the urllib3.HTTPResponse object will
@@ -21696,7 +20152,7 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: tuple(LogsoutputResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(SessionsshkeyResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -21704,11 +20160,7 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'session_id',
-            'start_line',
-            'end_line',
-            'extension',
-            'start_time'
+            'session_id'
         ]
         all_params.extend(
             [
@@ -21723,22 +20175,14 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_startup_logs_api_v2_sessions_session_id_startup_logs_get" % key
+                    " to method get_session_ssh_key_api_v2_sessions_session_id_ssh_key_get" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
         # verify the required parameter 'session_id' is set
         if self.api_client.client_side_validation and ('session_id' not in local_var_params or  # noqa: E501
                                                         local_var_params['session_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_id` when calling `get_startup_logs_api_v2_sessions_session_id_startup_logs_get`")  # noqa: E501
-        # verify the required parameter 'start_line' is set
-        if self.api_client.client_side_validation and ('start_line' not in local_var_params or  # noqa: E501
-                                                        local_var_params['start_line'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `start_line` when calling `get_startup_logs_api_v2_sessions_session_id_startup_logs_get`")  # noqa: E501
-        # verify the required parameter 'end_line' is set
-        if self.api_client.client_side_validation and ('end_line' not in local_var_params or  # noqa: E501
-                                                        local_var_params['end_line'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `end_line` when calling `get_startup_logs_api_v2_sessions_session_id_startup_logs_get`")  # noqa: E501
+            raise ApiValueError("Missing the required parameter `session_id` when calling `get_session_ssh_key_api_v2_sessions_session_id_ssh_key_get`")  # noqa: E501
 
         collection_formats = {}
 
@@ -21747,14 +20191,6 @@ class DefaultApi(object):
             path_params['session_id'] = local_var_params['session_id']  # noqa: E501
 
         query_params = []
-        if 'start_line' in local_var_params and local_var_params['start_line'] is not None:  # noqa: E501
-            query_params.append(('start_line', local_var_params['start_line']))  # noqa: E501
-        if 'end_line' in local_var_params and local_var_params['end_line'] is not None:  # noqa: E501
-            query_params.append(('end_line', local_var_params['end_line']))  # noqa: E501
-        if 'extension' in local_var_params and local_var_params['extension'] is not None:  # noqa: E501
-            query_params.append(('extension', local_var_params['extension']))  # noqa: E501
-        if 'start_time' in local_var_params and local_var_params['start_time'] is not None:  # noqa: E501
-            query_params.append(('start_time', local_var_params['start_time']))  # noqa: E501
 
         header_params = {}
 
@@ -21770,14 +20206,14 @@ class DefaultApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/api/v2/sessions/{session_id}/startup_logs', 'GET',
+            '/api/v2/sessions/{session_id}/ssh_key', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='LogsoutputResponse',  # noqa: E501
+            response_type='SessionsshkeyResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=local_var_params.get('async_req'),
             _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
@@ -21785,16 +20221,20 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_startup_logs_archived_api_v2_sessions_session_id_startup_logs_archived_get(self, session_id, **kwargs):  # noqa: E501
-        """Get Startup Logs Archived  # noqa: E501
+    def get_startup_logs_api_v2_sessions_session_id_startup_logs_get(self, session_id, start_line, end_line, **kwargs):  # noqa: E501
+        """Get Startup Logs  # 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_startup_logs_archived_api_v2_sessions_session_id_startup_logs_archived_get(session_id, async_req=True)
+        >>> thread = api.get_startup_logs_api_v2_sessions_session_id_startup_logs_get(session_id, start_line, end_line, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
         :param str session_id: (required)
+        :param int start_line: (required)
+        :param int end_line: (required)
+        :param str extension:
+        :param datetime start_time:
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -21802,23 +20242,27 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: ArchivedlogsinfoResponse
+        :return: LogsoutputResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.get_startup_logs_archived_api_v2_sessions_session_id_startup_logs_archived_get_with_http_info(session_id, **kwargs)  # noqa: E501
+        return self.get_startup_logs_api_v2_sessions_session_id_startup_logs_get_with_http_info(session_id, start_line, end_line, **kwargs)  # noqa: E501
 
-    def get_startup_logs_archived_api_v2_sessions_session_id_startup_logs_archived_get_with_http_info(self, session_id, **kwargs):  # noqa: E501
-        """Get Startup Logs Archived  # noqa: E501
+    def get_startup_logs_api_v2_sessions_session_id_startup_logs_get_with_http_info(self, session_id, start_line, end_line, **kwargs):  # noqa: E501
+        """Get Startup Logs  # 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_startup_logs_archived_api_v2_sessions_session_id_startup_logs_archived_get_with_http_info(session_id, async_req=True)
+        >>> thread = api.get_startup_logs_api_v2_sessions_session_id_startup_logs_get_with_http_info(session_id, start_line, end_line, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
         :param str session_id: (required)
+        :param int start_line: (required)
+        :param int end_line: (required)
+        :param str extension:
+        :param datetime start_time:
         :param _return_http_data_only: response data without head status code
                                        and headers
         :param _preload_content: if False, the urllib3.HTTPResponse object will
@@ -21828,7 +20272,7 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: tuple(ArchivedlogsinfoResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(LogsoutputResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -21836,7 +20280,11 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'session_id'
+            'session_id',
+            'start_line',
+            'end_line',
+            'extension',
+            'start_time'
         ]
         all_params.extend(
             [
@@ -21851,14 +20299,22 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_startup_logs_archived_api_v2_sessions_session_id_startup_logs_archived_get" % key
+                    " to method get_startup_logs_api_v2_sessions_session_id_startup_logs_get" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
         # verify the required parameter 'session_id' is set
         if self.api_client.client_side_validation and ('session_id' not in local_var_params or  # noqa: E501
                                                         local_var_params['session_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_id` when calling `get_startup_logs_archived_api_v2_sessions_session_id_startup_logs_archived_get`")  # noqa: E501
+            raise ApiValueError("Missing the required parameter `session_id` when calling `get_startup_logs_api_v2_sessions_session_id_startup_logs_get`")  # noqa: E501
+        # verify the required parameter 'start_line' is set
+        if self.api_client.client_side_validation and ('start_line' not in local_var_params or  # noqa: E501
+                                                        local_var_params['start_line'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `start_line` when calling `get_startup_logs_api_v2_sessions_session_id_startup_logs_get`")  # noqa: E501
+        # verify the required parameter 'end_line' is set
+        if self.api_client.client_side_validation and ('end_line' not in local_var_params or  # noqa: E501
+                                                        local_var_params['end_line'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `end_line` when calling `get_startup_logs_api_v2_sessions_session_id_startup_logs_get`")  # noqa: E501
 
         collection_formats = {}
 
@@ -21867,6 +20323,14 @@ class DefaultApi(object):
             path_params['session_id'] = local_var_params['session_id']  # noqa: E501
 
         query_params = []
+        if 'start_line' in local_var_params and local_var_params['start_line'] is not None:  # noqa: E501
+            query_params.append(('start_line', local_var_params['start_line']))  # noqa: E501
+        if 'end_line' in local_var_params and local_var_params['end_line'] is not None:  # noqa: E501
+            query_params.append(('end_line', local_var_params['end_line']))  # noqa: E501
+        if 'extension' in local_var_params and local_var_params['extension'] is not None:  # noqa: E501
+            query_params.append(('extension', local_var_params['extension']))  # noqa: E501
+        if 'start_time' in local_var_params and local_var_params['start_time'] is not None:  # noqa: E501
+            query_params.append(('start_time', local_var_params['start_time']))  # noqa: E501
 
         header_params = {}
 
@@ -21882,14 +20346,14 @@ class DefaultApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/api/v2/sessions/{session_id}/startup_logs_archived', 'GET',
+            '/api/v2/sessions/{session_id}/startup_logs', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ArchivedlogsinfoResponse',  # noqa: E501
+            response_type='LogsoutputResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=local_var_params.get('async_req'),
             _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
@@ -22490,7 +20954,7 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: WorkspacereadmeResponse
+        :return: WorkspacetemplatereadmeResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -22517,7 +20981,7 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: tuple(WorkspacereadmeResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(WorkspacetemplatereadmeResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -22578,7 +21042,7 @@ class DefaultApi(object):
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='WorkspacereadmeResponse',  # noqa: E501
+            response_type='WorkspacetemplatereadmeResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=local_var_params.get('async_req'),
             _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
@@ -24820,118 +23284,6 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def kill_session_command_api_v2_session_commands_session_command_id_kill_post(self, session_command_id, **kwargs):  # noqa: E501
-        """Kill Session Command  # noqa: E501
-
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.kill_session_command_api_v2_session_commands_session_command_id_kill_post(session_command_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_command_id: (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: None
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.kill_session_command_api_v2_session_commands_session_command_id_kill_post_with_http_info(session_command_id, **kwargs)  # noqa: E501
-
-    def kill_session_command_api_v2_session_commands_session_command_id_kill_post_with_http_info(self, session_command_id, **kwargs):  # noqa: E501
-        """Kill Session Command  # noqa: E501
-
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.kill_session_command_api_v2_session_commands_session_command_id_kill_post_with_http_info(session_command_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_command_id: (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: None
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'session_command_id'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method kill_session_command_api_v2_session_commands_session_command_id_kill_post" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'session_command_id' is set
-        if self.api_client.client_side_validation and ('session_command_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['session_command_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_command_id` when calling `kill_session_command_api_v2_session_commands_session_command_id_kill_post`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'session_command_id' in local_var_params:
-            path_params['session_command_id'] = local_var_params['session_command_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'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/session_commands/{session_command_id}/kill', 'POST',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type=None,  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
     def list_application_templates_api_v2_application_templates_get(self, **kwargs):  # noqa: E501
         """List Application Templates  # noqa: E501
 
@@ -28841,120 +27193,6 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def list_web_terminals_api_v2_sessions_session_id_web_terminals_get(self, session_id, **kwargs):  # noqa: E501
-        """List Web Terminals  # noqa: E501
-
-        DEPRECATED: This API is no deprecated and will not be supported in Anyscale 2.0  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_web_terminals_api_v2_sessions_session_id_web_terminals_get(session_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: WebterminalListResponse
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-        kwargs['_return_http_data_only'] = True
-        return self.list_web_terminals_api_v2_sessions_session_id_web_terminals_get_with_http_info(session_id, **kwargs)  # noqa: E501
-
-    def list_web_terminals_api_v2_sessions_session_id_web_terminals_get_with_http_info(self, session_id, **kwargs):  # noqa: E501
-        """List Web Terminals  # noqa: E501
-
-        DEPRECATED: This API is no deprecated and will not be supported in Anyscale 2.0  # noqa: E501
-        This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.list_web_terminals_api_v2_sessions_session_id_web_terminals_get_with_http_info(session_id, async_req=True)
-        >>> result = thread.get()
-
-        :param async_req bool: execute request asynchronously
-        :param str session_id: (required)
-        :param _return_http_data_only: response data without head status code
-                                       and headers
-        :param _preload_content: if False, the urllib3.HTTPResponse object will
-                                 be returned without reading/decoding response
-                                 data. Default is True.
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :return: tuple(WebterminalListResponse, status_code(int), headers(HTTPHeaderDict))
-                 If the method is called asynchronously,
-                 returns the request thread.
-        """
-
-        local_var_params = locals()
-
-        all_params = [
-            'session_id'
-        ]
-        all_params.extend(
-            [
-                'async_req',
-                '_return_http_data_only',
-                '_preload_content',
-                '_request_timeout'
-            ]
-        )
-
-        for key, val in six.iteritems(local_var_params['kwargs']):
-            if key not in all_params:
-                raise ApiTypeError(
-                    "Got an unexpected keyword argument '%s'"
-                    " to method list_web_terminals_api_v2_sessions_session_id_web_terminals_get" % key
-                )
-            local_var_params[key] = val
-        del local_var_params['kwargs']
-        # verify the required parameter 'session_id' is set
-        if self.api_client.client_side_validation and ('session_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['session_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `session_id` when calling `list_web_terminals_api_v2_sessions_session_id_web_terminals_get`")  # noqa: E501
-
-        collection_formats = {}
-
-        path_params = {}
-        if 'session_id' in local_var_params:
-            path_params['session_id'] = local_var_params['session_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'])  # noqa: E501
-
-        # Authentication setting
-        auth_settings = []  # noqa: E501
-
-        return self.api_client.call_api(
-            '/api/v2/sessions/{session_id}/web_terminals', 'GET',
-            path_params,
-            query_params,
-            header_params,
-            body=body_params,
-            post_params=form_params,
-            files=local_var_files,
-            response_type='WebterminalListResponse',  # noqa: E501
-            auth_settings=auth_settings,
-            async_req=local_var_params.get('async_req'),
-            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
-            _preload_content=local_var_params.get('_preload_content', True),
-            _request_timeout=local_var_params.get('_request_timeout'),
-            collection_formats=collection_formats)
-
     def list_workspace_templates_api_v2_experimental_workspaces_templates_get(self, **kwargs):  # noqa: E501
         """List Workspace Templates  # noqa: E501
 
@@ -35905,18 +34143,17 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put(self, cloud_id, update_cloud_with_cloud_resource_gcp, **kwargs):  # noqa: E501
-        """Update Cloud With Cloud Resource  # noqa: E501
+    def update_cloud_deployments_api_v2_clouds_cloud_id_deployments_put(self, cloud_id, cloud_deployment, **kwargs):  # noqa: E501
+        """Update Cloud Deployments  # noqa: E501
 
-        Updates a Cloud with CloudResource.  # 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_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put(cloud_id, update_cloud_with_cloud_resource_gcp, async_req=True)
+        >>> thread = api.update_cloud_deployments_api_v2_clouds_cloud_id_deployments_put(cloud_id, cloud_deployment, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
         :param str cloud_id: (required)
-        :param UpdateCloudWithCloudResourceGCP update_cloud_with_cloud_resource_gcp: (required)
+        :param list[CloudDeployment] cloud_deployment: (required)
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -35924,25 +34161,24 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: CloudwithcloudresourcegcpResponse
+        :return: object
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put_with_http_info(cloud_id, update_cloud_with_cloud_resource_gcp, **kwargs)  # noqa: E501
+        return self.update_cloud_deployments_api_v2_clouds_cloud_id_deployments_put_with_http_info(cloud_id, cloud_deployment, **kwargs)  # noqa: E501
 
-    def update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put_with_http_info(self, cloud_id, update_cloud_with_cloud_resource_gcp, **kwargs):  # noqa: E501
-        """Update Cloud With Cloud Resource  # noqa: E501
+    def update_cloud_deployments_api_v2_clouds_cloud_id_deployments_put_with_http_info(self, cloud_id, cloud_deployment, **kwargs):  # noqa: E501
+        """Update Cloud Deployments  # noqa: E501
 
-        Updates a Cloud with CloudResource.  # 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_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put_with_http_info(cloud_id, update_cloud_with_cloud_resource_gcp, async_req=True)
+        >>> thread = api.update_cloud_deployments_api_v2_clouds_cloud_id_deployments_put_with_http_info(cloud_id, cloud_deployment, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
         :param str cloud_id: (required)
-        :param UpdateCloudWithCloudResourceGCP update_cloud_with_cloud_resource_gcp: (required)
+        :param list[CloudDeployment] cloud_deployment: (required)
         :param _return_http_data_only: response data without head status code
                                        and headers
         :param _preload_content: if False, the urllib3.HTTPResponse object will
@@ -35952,7 +34188,7 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: tuple(CloudwithcloudresourcegcpResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(object, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -35961,7 +34197,7 @@ class DefaultApi(object):
 
         all_params = [
             'cloud_id',
-            'update_cloud_with_cloud_resource_gcp'
+            'cloud_deployment'
         ]
         all_params.extend(
             [
@@ -35976,18 +34212,18 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put" % key
+                    " to method update_cloud_deployments_api_v2_clouds_cloud_id_deployments_put" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
         # verify the required parameter 'cloud_id' is set
         if self.api_client.client_side_validation and ('cloud_id' not in local_var_params or  # noqa: E501
                                                         local_var_params['cloud_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `cloud_id` when calling `update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put`")  # noqa: E501
-        # verify the required parameter 'update_cloud_with_cloud_resource_gcp' is set
-        if self.api_client.client_side_validation and ('update_cloud_with_cloud_resource_gcp' not in local_var_params or  # noqa: E501
-                                                        local_var_params['update_cloud_with_cloud_resource_gcp'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `update_cloud_with_cloud_resource_gcp` when calling `update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put`")  # noqa: E501
+            raise ApiValueError("Missing the required parameter `cloud_id` when calling `update_cloud_deployments_api_v2_clouds_cloud_id_deployments_put`")  # noqa: E501
+        # verify the required parameter 'cloud_deployment' is set
+        if self.api_client.client_side_validation and ('cloud_deployment' not in local_var_params or  # noqa: E501
+                                                        local_var_params['cloud_deployment'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `cloud_deployment` when calling `update_cloud_deployments_api_v2_clouds_cloud_id_deployments_put`")  # noqa: E501
 
         collection_formats = {}
 
@@ -36003,8 +34239,8 @@ class DefaultApi(object):
         local_var_files = {}
 
         body_params = None
-        if 'update_cloud_with_cloud_resource_gcp' in local_var_params:
-            body_params = local_var_params['update_cloud_with_cloud_resource_gcp']
+        if 'cloud_deployment' in local_var_params:
+            body_params = local_var_params['cloud_deployment']
         # HTTP header `Accept`
         header_params['Accept'] = self.api_client.select_header_accept(
             ['application/json'])  # noqa: E501
@@ -36017,14 +34253,14 @@ class DefaultApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/api/v2/clouds_with_cloud_resource_gcp_router/{cloud_id}', 'PUT',
+            '/api/v2/clouds/{cloud_id}/deployments', 'PUT',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='CloudwithcloudresourcegcpResponse',  # noqa: E501
+            response_type='object',  # noqa: E501
             auth_settings=auth_settings,
             async_req=local_var_params.get('async_req'),
             _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
@@ -36032,18 +34268,18 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put(self, cloud_id, update_cloud_with_cloud_resource, **kwargs):  # noqa: E501
+    def update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put(self, cloud_id, update_cloud_with_cloud_resource_gcp, **kwargs):  # noqa: E501
         """Update Cloud With Cloud Resource  # noqa: E501
 
         Updates a Cloud with CloudResource.  # 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_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put(cloud_id, update_cloud_with_cloud_resource, async_req=True)
+        >>> thread = api.update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put(cloud_id, update_cloud_with_cloud_resource_gcp, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
         :param str cloud_id: (required)
-        :param UpdateCloudWithCloudResource update_cloud_with_cloud_resource: (required)
+        :param UpdateCloudWithCloudResourceGCP update_cloud_with_cloud_resource_gcp: (required)
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -36051,25 +34287,25 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: CloudwithcloudresourceResponse
+        :return: CloudwithcloudresourcegcpResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put_with_http_info(cloud_id, update_cloud_with_cloud_resource, **kwargs)  # noqa: E501
+        return self.update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put_with_http_info(cloud_id, update_cloud_with_cloud_resource_gcp, **kwargs)  # noqa: E501
 
-    def update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put_with_http_info(self, cloud_id, update_cloud_with_cloud_resource, **kwargs):  # noqa: E501
+    def update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put_with_http_info(self, cloud_id, update_cloud_with_cloud_resource_gcp, **kwargs):  # noqa: E501
         """Update Cloud With Cloud Resource  # noqa: E501
 
         Updates a Cloud with CloudResource.  # 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_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put_with_http_info(cloud_id, update_cloud_with_cloud_resource, async_req=True)
+        >>> thread = api.update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put_with_http_info(cloud_id, update_cloud_with_cloud_resource_gcp, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
         :param str cloud_id: (required)
-        :param UpdateCloudWithCloudResource update_cloud_with_cloud_resource: (required)
+        :param UpdateCloudWithCloudResourceGCP update_cloud_with_cloud_resource_gcp: (required)
         :param _return_http_data_only: response data without head status code
                                        and headers
         :param _preload_content: if False, the urllib3.HTTPResponse object will
@@ -36079,7 +34315,7 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: tuple(CloudwithcloudresourceResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(CloudwithcloudresourcegcpResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -36088,7 +34324,7 @@ class DefaultApi(object):
 
         all_params = [
             'cloud_id',
-            'update_cloud_with_cloud_resource'
+            'update_cloud_with_cloud_resource_gcp'
         ]
         all_params.extend(
             [
@@ -36103,18 +34339,18 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put" % key
+                    " to method update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
         # verify the required parameter 'cloud_id' is set
         if self.api_client.client_side_validation and ('cloud_id' not in local_var_params or  # noqa: E501
                                                         local_var_params['cloud_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `cloud_id` when calling `update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put`")  # noqa: E501
-        # verify the required parameter 'update_cloud_with_cloud_resource' is set
-        if self.api_client.client_side_validation and ('update_cloud_with_cloud_resource' not in local_var_params or  # noqa: E501
-                                                        local_var_params['update_cloud_with_cloud_resource'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `update_cloud_with_cloud_resource` when calling `update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put`")  # noqa: E501
+            raise ApiValueError("Missing the required parameter `cloud_id` when calling `update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put`")  # noqa: E501
+        # verify the required parameter 'update_cloud_with_cloud_resource_gcp' is set
+        if self.api_client.client_side_validation and ('update_cloud_with_cloud_resource_gcp' not in local_var_params or  # noqa: E501
+                                                        local_var_params['update_cloud_with_cloud_resource_gcp'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `update_cloud_with_cloud_resource_gcp` when calling `update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_gcp_router_cloud_id_put`")  # noqa: E501
 
         collection_formats = {}
 
@@ -36130,8 +34366,8 @@ class DefaultApi(object):
         local_var_files = {}
 
         body_params = None
-        if 'update_cloud_with_cloud_resource' in local_var_params:
-            body_params = local_var_params['update_cloud_with_cloud_resource']
+        if 'update_cloud_with_cloud_resource_gcp' in local_var_params:
+            body_params = local_var_params['update_cloud_with_cloud_resource_gcp']
         # HTTP header `Accept`
         header_params['Accept'] = self.api_client.select_header_accept(
             ['application/json'])  # noqa: E501
@@ -36144,14 +34380,14 @@ class DefaultApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/api/v2/clouds_with_cloud_resource_router/{cloud_id}', 'PUT',
+            '/api/v2/clouds_with_cloud_resource_gcp_router/{cloud_id}', 'PUT',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='CloudwithcloudresourceResponse',  # noqa: E501
+            response_type='CloudwithcloudresourcegcpResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=local_var_params.get('async_req'),
             _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
@@ -36159,18 +34395,18 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def update_compute_template_api_v2_compute_templates_compute_template_id_put(self, compute_template_id, update_compute_template, **kwargs):  # noqa: E501
-        """Update Compute Template  # noqa: E501
+    def update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put(self, cloud_id, update_cloud_with_cloud_resource, **kwargs):  # noqa: E501
+        """Update Cloud With Cloud Resource  # noqa: E501
 
-        Updates a compute template. DEPRECATED: Compute templates will be immutable. Please create a new one instead of updating existing ones.  # noqa: E501
+        Updates a Cloud with CloudResource.  # 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_compute_template_api_v2_compute_templates_compute_template_id_put(compute_template_id, update_compute_template, async_req=True)
+        >>> thread = api.update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put(cloud_id, update_cloud_with_cloud_resource, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str compute_template_id: (required)
-        :param UpdateComputeTemplate update_compute_template: (required)
+        :param str cloud_id: (required)
+        :param UpdateCloudWithCloudResource update_cloud_with_cloud_resource: (required)
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -36178,25 +34414,25 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: ComputetemplateResponse
+        :return: CloudwithcloudresourceResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.update_compute_template_api_v2_compute_templates_compute_template_id_put_with_http_info(compute_template_id, update_compute_template, **kwargs)  # noqa: E501
+        return self.update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put_with_http_info(cloud_id, update_cloud_with_cloud_resource, **kwargs)  # noqa: E501
 
-    def update_compute_template_api_v2_compute_templates_compute_template_id_put_with_http_info(self, compute_template_id, update_compute_template, **kwargs):  # noqa: E501
-        """Update Compute Template  # noqa: E501
+    def update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put_with_http_info(self, cloud_id, update_cloud_with_cloud_resource, **kwargs):  # noqa: E501
+        """Update Cloud With Cloud Resource  # noqa: E501
 
-        Updates a compute template. DEPRECATED: Compute templates will be immutable. Please create a new one instead of updating existing ones.  # noqa: E501
+        Updates a Cloud with CloudResource.  # 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_compute_template_api_v2_compute_templates_compute_template_id_put_with_http_info(compute_template_id, update_compute_template, async_req=True)
+        >>> thread = api.update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put_with_http_info(cloud_id, update_cloud_with_cloud_resource, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str compute_template_id: (required)
-        :param UpdateComputeTemplate update_compute_template: (required)
+        :param str cloud_id: (required)
+        :param UpdateCloudWithCloudResource update_cloud_with_cloud_resource: (required)
         :param _return_http_data_only: response data without head status code
                                        and headers
         :param _preload_content: if False, the urllib3.HTTPResponse object will
@@ -36206,7 +34442,7 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: tuple(ComputetemplateResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(CloudwithcloudresourceResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -36214,8 +34450,8 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'compute_template_id',
-            'update_compute_template'
+            'cloud_id',
+            'update_cloud_with_cloud_resource'
         ]
         all_params.extend(
             [
@@ -36230,24 +34466,24 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method update_compute_template_api_v2_compute_templates_compute_template_id_put" % key
+                    " to method update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
-        # verify the required parameter 'compute_template_id' is set
-        if self.api_client.client_side_validation and ('compute_template_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['compute_template_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `compute_template_id` when calling `update_compute_template_api_v2_compute_templates_compute_template_id_put`")  # noqa: E501
-        # verify the required parameter 'update_compute_template' is set
-        if self.api_client.client_side_validation and ('update_compute_template' not in local_var_params or  # noqa: E501
-                                                        local_var_params['update_compute_template'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `update_compute_template` when calling `update_compute_template_api_v2_compute_templates_compute_template_id_put`")  # noqa: E501
+        # verify the required parameter 'cloud_id' is set
+        if self.api_client.client_side_validation and ('cloud_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['cloud_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `cloud_id` when calling `update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put`")  # noqa: E501
+        # verify the required parameter 'update_cloud_with_cloud_resource' is set
+        if self.api_client.client_side_validation and ('update_cloud_with_cloud_resource' not in local_var_params or  # noqa: E501
+                                                        local_var_params['update_cloud_with_cloud_resource'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `update_cloud_with_cloud_resource` when calling `update_cloud_with_cloud_resource_api_v2_clouds_with_cloud_resource_router_cloud_id_put`")  # noqa: E501
 
         collection_formats = {}
 
         path_params = {}
-        if 'compute_template_id' in local_var_params:
-            path_params['compute_template_id'] = local_var_params['compute_template_id']  # noqa: E501
+        if 'cloud_id' in local_var_params:
+            path_params['cloud_id'] = local_var_params['cloud_id']  # noqa: E501
 
         query_params = []
 
@@ -36257,8 +34493,8 @@ class DefaultApi(object):
         local_var_files = {}
 
         body_params = None
-        if 'update_compute_template' in local_var_params:
-            body_params = local_var_params['update_compute_template']
+        if 'update_cloud_with_cloud_resource' in local_var_params:
+            body_params = local_var_params['update_cloud_with_cloud_resource']
         # HTTP header `Accept`
         header_params['Accept'] = self.api_client.select_header_accept(
             ['application/json'])  # noqa: E501
@@ -36271,14 +34507,14 @@ class DefaultApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/api/v2/compute_templates/{compute_template_id}', 'PUT',
+            '/api/v2/clouds_with_cloud_resource_router/{cloud_id}', 'PUT',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ComputetemplateResponse',  # noqa: E501
+            response_type='CloudwithcloudresourceResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=local_var_params.get('async_req'),
             _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
@@ -36761,6 +34997,133 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def update_job_queue_api_v2_job_queues_job_queue_id_put(self, job_queue_id, update_job_queue_request, **kwargs):  # noqa: E501
+        """Update Job Queue  # noqa: E501
+
+        Update a job queue.  # 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_job_queue_api_v2_job_queues_job_queue_id_put(job_queue_id, update_job_queue_request, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str job_queue_id: (required)
+        :param UpdateJobQueueRequest update_job_queue_request: (required)
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: DecoratedjobqueueResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.update_job_queue_api_v2_job_queues_job_queue_id_put_with_http_info(job_queue_id, update_job_queue_request, **kwargs)  # noqa: E501
+
+    def update_job_queue_api_v2_job_queues_job_queue_id_put_with_http_info(self, job_queue_id, update_job_queue_request, **kwargs):  # noqa: E501
+        """Update Job Queue  # noqa: E501
+
+        Update a job queue.  # 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_job_queue_api_v2_job_queues_job_queue_id_put_with_http_info(job_queue_id, update_job_queue_request, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str job_queue_id: (required)
+        :param UpdateJobQueueRequest update_job_queue_request: (required)
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: tuple(DecoratedjobqueueResponse, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'job_queue_id',
+            'update_job_queue_request'
+        ]
+        all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout'
+            ]
+        )
+
+        for key, val in six.iteritems(local_var_params['kwargs']):
+            if key not in all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method update_job_queue_api_v2_job_queues_job_queue_id_put" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'job_queue_id' is set
+        if self.api_client.client_side_validation and ('job_queue_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['job_queue_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `job_queue_id` when calling `update_job_queue_api_v2_job_queues_job_queue_id_put`")  # noqa: E501
+        # verify the required parameter 'update_job_queue_request' is set
+        if self.api_client.client_side_validation and ('update_job_queue_request' not in local_var_params or  # noqa: E501
+                                                        local_var_params['update_job_queue_request'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `update_job_queue_request` when calling `update_job_queue_api_v2_job_queues_job_queue_id_put`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'job_queue_id' in local_var_params:
+            path_params['job_queue_id'] = local_var_params['job_queue_id']  # noqa: E501
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'update_job_queue_request' in local_var_params:
+            body_params = local_var_params['update_job_queue_request']
+        # HTTP header `Accept`
+        header_params['Accept'] = self.api_client.select_header_accept(
+            ['application/json'])  # noqa: E501
+
+        # HTTP header `Content-Type`
+        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
+            ['application/json'])  # noqa: E501
+
+        # Authentication setting
+        auth_settings = []  # noqa: E501
+
+        return self.api_client.call_api(
+            '/api/v2/job_queues/{job_queue_id}', 'PUT',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DecoratedjobqueueResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=local_var_params.get('async_req'),
+            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=local_var_params.get('_preload_content', True),
+            _request_timeout=local_var_params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def update_job_queue_config_api_v2_decorated_ha_jobs_production_job_id_update_job_queue_config_put(self, production_job_id, job_queue_config, **kwargs):  # noqa: E501
         """Update Job Queue Config  # noqa: E501