anyscale 0.26.57__py3-none-any.whl → 0.26.59__py3-none-any.whl

anyscale/client/openapi_client/api/default_api.py

@@ -6303,6 +6303,251 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def create_template_api_v2_workspace_templates_post(self, create_workspace_template, **kwargs):  # noqa: E501
+        """Create Template  # noqa: E501
+
+        Create a new workspace template  # 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_template_api_v2_workspace_templates_post(create_workspace_template, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param CreateWorkspaceTemplate create_workspace_template: (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: WorkspacetemplateResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.create_template_api_v2_workspace_templates_post_with_http_info(create_workspace_template, **kwargs)  # noqa: E501
+
+    def create_template_api_v2_workspace_templates_post_with_http_info(self, create_workspace_template, **kwargs):  # noqa: E501
+        """Create Template  # noqa: E501
+
+        Create a new workspace template  # 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_template_api_v2_workspace_templates_post_with_http_info(create_workspace_template, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param CreateWorkspaceTemplate create_workspace_template: (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(WorkspacetemplateResponse, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'create_workspace_template'
+        ]
+        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_template_api_v2_workspace_templates_post" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'create_workspace_template' is set
+        if self.api_client.client_side_validation and ('create_workspace_template' not in local_var_params or  # noqa: E501
+                                                        local_var_params['create_workspace_template'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `create_workspace_template` when calling `create_template_api_v2_workspace_templates_post`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'create_workspace_template' in local_var_params:
+            body_params = local_var_params['create_workspace_template']
+        # 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/workspace_templates/', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='WorkspacetemplateResponse',  # 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_version_api_v2_workspace_templates_template_id_versions_post(self, template_id, create_workspace_template_version, **kwargs):  # noqa: E501
+        """Create Version  # noqa: E501
+
+        Create a new version for a workspace template  # 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_version_api_v2_workspace_templates_template_id_versions_post(template_id, create_workspace_template_version, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str template_id: (required)
+        :param CreateWorkspaceTemplateVersion create_workspace_template_version: (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: object
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.create_version_api_v2_workspace_templates_template_id_versions_post_with_http_info(template_id, create_workspace_template_version, **kwargs)  # noqa: E501
+
+    def create_version_api_v2_workspace_templates_template_id_versions_post_with_http_info(self, template_id, create_workspace_template_version, **kwargs):  # noqa: E501
+        """Create Version  # noqa: E501
+
+        Create a new version for a workspace template  # 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_version_api_v2_workspace_templates_template_id_versions_post_with_http_info(template_id, create_workspace_template_version, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str template_id: (required)
+        :param CreateWorkspaceTemplateVersion create_workspace_template_version: (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(object, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'template_id',
+            'create_workspace_template_version'
+        ]
+        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_version_api_v2_workspace_templates_template_id_versions_post" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'template_id' is set
+        if self.api_client.client_side_validation and ('template_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['template_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `template_id` when calling `create_version_api_v2_workspace_templates_template_id_versions_post`")  # noqa: E501
+        # verify the required parameter 'create_workspace_template_version' is set
+        if self.api_client.client_side_validation and ('create_workspace_template_version' not in local_var_params or  # noqa: E501
+                                                        local_var_params['create_workspace_template_version'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `create_workspace_template_version` when calling `create_version_api_v2_workspace_templates_template_id_versions_post`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'template_id' in local_var_params:
+            path_params['template_id'] = local_var_params['template_id']  # noqa: E501
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'create_workspace_template_version' in local_var_params:
+            body_params = local_var_params['create_workspace_template_version']
+        # 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/workspace_templates/{template_id}/versions', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            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
+            _preload_content=local_var_params.get('_preload_content', True),
+            _request_timeout=local_var_params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def create_workspace_api_v2_experimental_workspaces_post(self, create_experimental_workspace, **kwargs):  # noqa: E501
         """Create Workspace  # noqa: E501
 
@@ -7809,17 +8054,16 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def delete_service_api_v2_services_v2_service_id_delete(self, service_id, **kwargs):  # noqa: E501
-        """Delete Service  # noqa: E501
+    def delete_resource_tags_api_v2_tags_resource_delete(self, delete_resource_tags_request, **kwargs):  # noqa: E501
+        """Delete Resource Tags  # noqa: E501
 
-        Deletes a Service.  # 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_service_api_v2_services_v2_service_id_delete(service_id, async_req=True)
+        >>> thread = api.delete_resource_tags_api_v2_tags_resource_delete(delete_resource_tags_request, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str service_id: (required)
+        :param DeleteResourceTagsRequest delete_resource_tags_request: (required)
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -7827,24 +8071,23 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: None
+        :return: DeletedcountResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.delete_service_api_v2_services_v2_service_id_delete_with_http_info(service_id, **kwargs)  # noqa: E501
+        return self.delete_resource_tags_api_v2_tags_resource_delete_with_http_info(delete_resource_tags_request, **kwargs)  # noqa: E501
 
-    def delete_service_api_v2_services_v2_service_id_delete_with_http_info(self, service_id, **kwargs):  # noqa: E501
-        """Delete Service  # noqa: E501
+    def delete_resource_tags_api_v2_tags_resource_delete_with_http_info(self, delete_resource_tags_request, **kwargs):  # noqa: E501
+        """Delete Resource Tags  # noqa: E501
 
-        Deletes a Service.  # 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_service_api_v2_services_v2_service_id_delete_with_http_info(service_id, async_req=True)
+        >>> thread = api.delete_resource_tags_api_v2_tags_resource_delete_with_http_info(delete_resource_tags_request, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str service_id: (required)
+        :param DeleteResourceTagsRequest delete_resource_tags_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
@@ -7854,7 +8097,7 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: None
+        :return: tuple(DeletedcountResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -7862,7 +8105,7 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'service_id'
+            'delete_resource_tags_request'
         ]
         all_params.extend(
             [
@@ -7877,20 +8120,18 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_service_api_v2_services_v2_service_id_delete" % key
+                    " to method delete_resource_tags_api_v2_tags_resource_delete" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
-        # verify the required parameter 'service_id' is set
-        if self.api_client.client_side_validation and ('service_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['service_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `service_id` when calling `delete_service_api_v2_services_v2_service_id_delete`")  # noqa: E501
+        # verify the required parameter 'delete_resource_tags_request' is set
+        if self.api_client.client_side_validation and ('delete_resource_tags_request' not in local_var_params or  # noqa: E501
+                                                        local_var_params['delete_resource_tags_request'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `delete_resource_tags_request` when calling `delete_resource_tags_api_v2_tags_resource_delete`")  # noqa: E501
 
         collection_formats = {}
 
         path_params = {}
-        if 'service_id' in local_var_params:
-            path_params['service_id'] = local_var_params['service_id']  # noqa: E501
 
         query_params = []
 
@@ -7900,22 +8141,28 @@ class DefaultApi(object):
         local_var_files = {}
 
         body_params = None
+        if 'delete_resource_tags_request' in local_var_params:
+            body_params = local_var_params['delete_resource_tags_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/services-v2/{service_id}', 'DELETE',
+            '/api/v2/tags/resource', 'DELETE',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type=None,  # noqa: E501
+            response_type='DeletedcountResponse',  # 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
@@ -7923,17 +8170,17 @@ class DefaultApi(object):
             _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
+    def delete_service_api_v2_services_v2_service_id_delete(self, service_id, **kwargs):  # noqa: E501
+        """Delete Service  # noqa: E501
 
-        Deletes a Workspace.  # noqa: E501
+        Deletes a Service.  # 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_workspace_api_v2_experimental_workspaces_workspace_id_delete(workspace_id, async_req=True)
+        >>> thread = api.delete_service_api_v2_services_v2_service_id_delete(service_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str workspace_id: ID of the Workspace to delete. (required)
+        :param str service_id: (required)
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -7946,19 +8193,19 @@ class DefaultApi(object):
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.delete_workspace_api_v2_experimental_workspaces_workspace_id_delete_with_http_info(workspace_id, **kwargs)  # noqa: E501
+        return self.delete_service_api_v2_services_v2_service_id_delete_with_http_info(service_id, **kwargs)  # noqa: E501
 
-    def delete_workspace_api_v2_experimental_workspaces_workspace_id_delete_with_http_info(self, workspace_id, **kwargs):  # noqa: E501
-        """Delete Workspace  # noqa: E501
+    def delete_service_api_v2_services_v2_service_id_delete_with_http_info(self, service_id, **kwargs):  # noqa: E501
+        """Delete Service  # noqa: E501
 
-        Deletes a Workspace.  # noqa: E501
+        Deletes a Service.  # 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_workspace_api_v2_experimental_workspaces_workspace_id_delete_with_http_info(workspace_id, async_req=True)
+        >>> thread = api.delete_service_api_v2_services_v2_service_id_delete_with_http_info(service_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str workspace_id: ID of the Workspace to delete. (required)
+        :param str service_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
@@ -7976,7 +8223,7 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'workspace_id'
+            'service_id'
         ]
         all_params.extend(
             [
@@ -7991,12 +8238,126 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method delete_workspace_api_v2_experimental_workspaces_workspace_id_delete" % key
+                    " to method delete_service_api_v2_services_v2_service_id_delete" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
-        # verify the required parameter 'workspace_id' is set
-        if self.api_client.client_side_validation and ('workspace_id' not in local_var_params or  # noqa: E501
+        # verify the required parameter 'service_id' is set
+        if self.api_client.client_side_validation and ('service_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['service_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `service_id` when calling `delete_service_api_v2_services_v2_service_id_delete`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'service_id' in local_var_params:
+            path_params['service_id'] = local_var_params['service_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/services-v2/{service_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
+
+        Deletes a Workspace.  # 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_workspace_api_v2_experimental_workspaces_workspace_id_delete(workspace_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str workspace_id: ID of the Workspace to delete. (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_workspace_api_v2_experimental_workspaces_workspace_id_delete_with_http_info(workspace_id, **kwargs)  # noqa: E501
+
+    def delete_workspace_api_v2_experimental_workspaces_workspace_id_delete_with_http_info(self, workspace_id, **kwargs):  # noqa: E501
+        """Delete Workspace  # noqa: E501
+
+        Deletes a Workspace.  # 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_workspace_api_v2_experimental_workspaces_workspace_id_delete_with_http_info(workspace_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str workspace_id: ID of the Workspace to delete. (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 = [
+            'workspace_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_workspace_api_v2_experimental_workspaces_workspace_id_delete" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'workspace_id' is set
+        if self.api_client.client_side_validation and ('workspace_id' not in local_var_params or  # noqa: E501
                                                         local_var_params['workspace_id'] is None):  # noqa: E501
             raise ApiValueError("Missing the required parameter `workspace_id` when calling `delete_workspace_api_v2_experimental_workspaces_workspace_id_delete`")  # noqa: E501
 
@@ -17289,6 +17650,145 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def get_operator_events_api_v2_dataset_runs_operator_events_get(self, cluster_id, session_name, dataset_id, operator_id, **kwargs):  # noqa: E501
+        """Get Operator Events  # 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_operator_events_api_v2_dataset_runs_operator_events_get(cluster_id, session_name, dataset_id, operator_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str cluster_id: (required)
+        :param str session_name: (required)
+        :param str dataset_id: (required)
+        :param str operator_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: OperatorEventResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.get_operator_events_api_v2_dataset_runs_operator_events_get_with_http_info(cluster_id, session_name, dataset_id, operator_id, **kwargs)  # noqa: E501
+
+    def get_operator_events_api_v2_dataset_runs_operator_events_get_with_http_info(self, cluster_id, session_name, dataset_id, operator_id, **kwargs):  # noqa: E501
+        """Get Operator Events  # 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_operator_events_api_v2_dataset_runs_operator_events_get_with_http_info(cluster_id, session_name, dataset_id, operator_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str cluster_id: (required)
+        :param str session_name: (required)
+        :param str dataset_id: (required)
+        :param str operator_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(OperatorEventResponse, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'cluster_id',
+            'session_name',
+            'dataset_id',
+            'operator_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_operator_events_api_v2_dataset_runs_operator_events_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_operator_events_api_v2_dataset_runs_operator_events_get`")  # noqa: E501
+        # verify the required parameter 'session_name' is set
+        if self.api_client.client_side_validation and ('session_name' not in local_var_params or  # noqa: E501
+                                                        local_var_params['session_name'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `session_name` when calling `get_operator_events_api_v2_dataset_runs_operator_events_get`")  # noqa: E501
+        # verify the required parameter 'dataset_id' is set
+        if self.api_client.client_side_validation and ('dataset_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['dataset_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `dataset_id` when calling `get_operator_events_api_v2_dataset_runs_operator_events_get`")  # noqa: E501
+        # verify the required parameter 'operator_id' is set
+        if self.api_client.client_side_validation and ('operator_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['operator_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `operator_id` when calling `get_operator_events_api_v2_dataset_runs_operator_events_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 'session_name' in local_var_params and local_var_params['session_name'] is not None:  # noqa: E501
+            query_params.append(('session_name', local_var_params['session_name']))  # noqa: E501
+        if 'dataset_id' in local_var_params and local_var_params['dataset_id'] is not None:  # noqa: E501
+            query_params.append(('dataset_id', local_var_params['dataset_id']))  # noqa: E501
+        if 'operator_id' in local_var_params and local_var_params['operator_id'] is not None:  # noqa: E501
+            query_params.append(('operator_id', local_var_params['operator_id']))  # 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/dataset_runs/operator_events', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='OperatorEventResponse',  # 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
 
@@ -20272,16 +20772,17 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_task_exception_aggregates_api_v2_tasks_dashboard_aggregate_by_exception_get(self, cluster_id, **kwargs):  # noqa: E501
-        """Get Task Exception Aggregates  # noqa: E501
+    def get_tags_for_resource_api_v2_tags_resource_get(self, resource_type, resource_id, **kwargs):  # noqa: E501
+        """Get Tags For Resource  # 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_task_exception_aggregates_api_v2_tasks_dashboard_aggregate_by_exception_get(cluster_id, async_req=True)
+        >>> thread = api.get_tags_for_resource_api_v2_tags_resource_get(resource_type, resource_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str cluster_id: (required)
+        :param ResourceTagResourceType resource_type: (required)
+        :param str resource_id: (required)
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -20289,23 +20790,24 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: TaskExceptionGroupAggregateResponse
+        :return: ResourcetagslistResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.get_task_exception_aggregates_api_v2_tasks_dashboard_aggregate_by_exception_get_with_http_info(cluster_id, **kwargs)  # noqa: E501
+        return self.get_tags_for_resource_api_v2_tags_resource_get_with_http_info(resource_type, resource_id, **kwargs)  # noqa: E501
 
-    def get_task_exception_aggregates_api_v2_tasks_dashboard_aggregate_by_exception_get_with_http_info(self, cluster_id, **kwargs):  # noqa: E501
-        """Get Task Exception Aggregates  # noqa: E501
+    def get_tags_for_resource_api_v2_tags_resource_get_with_http_info(self, resource_type, resource_id, **kwargs):  # noqa: E501
+        """Get Tags For Resource  # 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_task_exception_aggregates_api_v2_tasks_dashboard_aggregate_by_exception_get_with_http_info(cluster_id, async_req=True)
+        >>> thread = api.get_tags_for_resource_api_v2_tags_resource_get_with_http_info(resource_type, resource_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str cluster_id: (required)
+        :param ResourceTagResourceType resource_type: (required)
+        :param str resource_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
@@ -20315,7 +20817,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(TaskExceptionGroupAggregateResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(ResourcetagslistResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -20323,7 +20825,8 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'cluster_id'
+            'resource_type',
+            'resource_id'
         ]
         all_params.extend(
             [
@@ -20338,21 +20841,139 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_task_exception_aggregates_api_v2_tasks_dashboard_aggregate_by_exception_get" % key
+                    " to method get_tags_for_resource_api_v2_tags_resource_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_task_exception_aggregates_api_v2_tasks_dashboard_aggregate_by_exception_get`")  # noqa: E501
+        # verify the required parameter 'resource_type' is set
+        if self.api_client.client_side_validation and ('resource_type' not in local_var_params or  # noqa: E501
+                                                        local_var_params['resource_type'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `resource_type` when calling `get_tags_for_resource_api_v2_tags_resource_get`")  # noqa: E501
+        # verify the required parameter 'resource_id' is set
+        if self.api_client.client_side_validation and ('resource_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['resource_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `resource_id` when calling `get_tags_for_resource_api_v2_tags_resource_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
+        if 'resource_type' in local_var_params and local_var_params['resource_type'] is not None:  # noqa: E501
+            query_params.append(('resource_type', local_var_params['resource_type']))  # noqa: E501
+        if 'resource_id' in local_var_params and local_var_params['resource_id'] is not None:  # noqa: E501
+            query_params.append(('resource_id', local_var_params['resource_id']))  # 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/tags/resource', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ResourcetagslistResponse',  # 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_task_exception_aggregates_api_v2_tasks_dashboard_aggregate_by_exception_get(self, cluster_id, **kwargs):  # noqa: E501
+        """Get Task Exception Aggregates  # 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_task_exception_aggregates_api_v2_tasks_dashboard_aggregate_by_exception_get(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: TaskExceptionGroupAggregateResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.get_task_exception_aggregates_api_v2_tasks_dashboard_aggregate_by_exception_get_with_http_info(cluster_id, **kwargs)  # noqa: E501
+
+    def get_task_exception_aggregates_api_v2_tasks_dashboard_aggregate_by_exception_get_with_http_info(self, cluster_id, **kwargs):  # noqa: E501
+        """Get Task Exception Aggregates  # 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_task_exception_aggregates_api_v2_tasks_dashboard_aggregate_by_exception_get_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: tuple(TaskExceptionGroupAggregateResponse, status_code(int), headers(HTTPHeaderDict))
+                 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 get_task_exception_aggregates_api_v2_tasks_dashboard_aggregate_by_exception_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_task_exception_aggregates_api_v2_tasks_dashboard_aggregate_by_exception_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
 
         header_params = {}
@@ -20847,6 +21468,120 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def get_template_api_v2_workspace_templates_template_id_get(self, template_id, **kwargs):  # noqa: E501
+        """Get Template  # noqa: E501
+
+        Get workspace template 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_template_api_v2_workspace_templates_template_id_get(template_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str template_id: ID of the template to retrieve (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: WorkspacetemplateResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.get_template_api_v2_workspace_templates_template_id_get_with_http_info(template_id, **kwargs)  # noqa: E501
+
+    def get_template_api_v2_workspace_templates_template_id_get_with_http_info(self, template_id, **kwargs):  # noqa: E501
+        """Get Template  # noqa: E501
+
+        Get workspace template 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_template_api_v2_workspace_templates_template_id_get_with_http_info(template_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str template_id: ID of the template to retrieve (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(WorkspacetemplateResponse, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'template_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_template_api_v2_workspace_templates_template_id_get" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'template_id' is set
+        if self.api_client.client_side_validation and ('template_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['template_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `template_id` when calling `get_template_api_v2_workspace_templates_template_id_get`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'template_id' in local_var_params:
+            path_params['template_id'] = local_var_params['template_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/workspace_templates/{template_id}', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='WorkspacetemplateResponse',  # 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_template_readme_api_v2_experimental_workspaces_template_readme_template_id_get(self, template_id, **kwargs):  # noqa: E501
         """Get Template Readme  # noqa: E501
 
@@ -21442,17 +22177,18 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_workspace_api_v2_experimental_workspaces_workspace_id_get(self, workspace_id, **kwargs):  # noqa: E501
-        """Get Workspace  # noqa: E501
+    def get_version_api_v2_workspace_templates_template_id_versions_version_id_get(self, template_id, version_id, **kwargs):  # noqa: E501
+        """Get Version  # noqa: E501
 
-        Retrieves a Workspace.  # noqa: E501
+        Get a specific version of a workspace template  # 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_workspace_api_v2_experimental_workspaces_workspace_id_get(workspace_id, async_req=True)
+        >>> thread = api.get_version_api_v2_workspace_templates_template_id_versions_version_id_get(template_id, version_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str workspace_id: ID of the Workspace to retreive. (required)
+        :param str template_id: (required)
+        :param str version_id: (required)
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -21460,24 +22196,25 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: ExperimentalworkspaceResponse
+        :return: WorkspacetemplateversionResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.get_workspace_api_v2_experimental_workspaces_workspace_id_get_with_http_info(workspace_id, **kwargs)  # noqa: E501
+        return self.get_version_api_v2_workspace_templates_template_id_versions_version_id_get_with_http_info(template_id, version_id, **kwargs)  # noqa: E501
 
-    def get_workspace_api_v2_experimental_workspaces_workspace_id_get_with_http_info(self, workspace_id, **kwargs):  # noqa: E501
-        """Get Workspace  # noqa: E501
+    def get_version_api_v2_workspace_templates_template_id_versions_version_id_get_with_http_info(self, template_id, version_id, **kwargs):  # noqa: E501
+        """Get Version  # noqa: E501
 
-        Retrieves a Workspace.  # noqa: E501
+        Get a specific version of a workspace template  # 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_workspace_api_v2_experimental_workspaces_workspace_id_get_with_http_info(workspace_id, async_req=True)
+        >>> thread = api.get_version_api_v2_workspace_templates_template_id_versions_version_id_get_with_http_info(template_id, version_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str workspace_id: ID of the Workspace to retreive. (required)
+        :param str template_id: (required)
+        :param str version_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
@@ -21487,7 +22224,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(ExperimentalworkspaceResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(WorkspacetemplateversionResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -21495,7 +22232,8 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'workspace_id'
+            'template_id',
+            'version_id'
         ]
         all_params.extend(
             [
@@ -21510,20 +22248,26 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_workspace_api_v2_experimental_workspaces_workspace_id_get" % key
+                    " to method get_version_api_v2_workspace_templates_template_id_versions_version_id_get" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
-        # verify the required parameter 'workspace_id' is set
-        if self.api_client.client_side_validation and ('workspace_id' not in local_var_params or  # noqa: E501
-                                                        local_var_params['workspace_id'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `workspace_id` when calling `get_workspace_api_v2_experimental_workspaces_workspace_id_get`")  # noqa: E501
+        # verify the required parameter 'template_id' is set
+        if self.api_client.client_side_validation and ('template_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['template_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `template_id` when calling `get_version_api_v2_workspace_templates_template_id_versions_version_id_get`")  # noqa: E501
+        # verify the required parameter 'version_id' is set
+        if self.api_client.client_side_validation and ('version_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['version_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `version_id` when calling `get_version_api_v2_workspace_templates_template_id_versions_version_id_get`")  # noqa: E501
 
         collection_formats = {}
 
         path_params = {}
-        if 'workspace_id' in local_var_params:
-            path_params['workspace_id'] = local_var_params['workspace_id']  # noqa: E501
+        if 'template_id' in local_var_params:
+            path_params['template_id'] = local_var_params['template_id']  # noqa: E501
+        if 'version_id' in local_var_params:
+            path_params['version_id'] = local_var_params['version_id']  # noqa: E501
 
         query_params = []
 
@@ -21541,14 +22285,14 @@ class DefaultApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/api/v2/experimental_workspaces/{workspace_id}', 'GET',
+            '/api/v2/workspace_templates/{template_id}/versions/{version_id}', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ExperimentalworkspaceResponse',  # noqa: E501
+            response_type='WorkspacetemplateversionResponse',  # 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
@@ -21556,18 +22300,17 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def get_workspace_dataplane_artifacts_api_v2_experimental_workspaces_workspace_id_dataplane_artifacts_get(self, workspace_id, **kwargs):  # noqa: E501
-        """Get Workspace Dataplane Artifacts  # noqa: E501
+    def get_workos_authorize_url_api_v2_workos_authorize_get(self, **kwargs):  # noqa: E501
+        """Get Workos Authorize Url  # noqa: E501
 
-        Retrieve workspace dataplane artifacts.  # 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_workspace_dataplane_artifacts_api_v2_experimental_workspaces_workspace_id_dataplane_artifacts_get(workspace_id, async_req=True)
+        >>> thread = api.get_workos_authorize_url_api_v2_workos_authorize_get(async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str workspace_id: ID of the Workspace to retrieve. (required)
-        :param CloudDataBucketAccessMode access_mode: Access mode for the workspace artifacts.
+        :param str email_address:
+        :param str provider:
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -21575,25 +22318,24 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: WorkspacedataplaneartifactsResponse
+        :return: WorkosauthorizeurlresponseResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.get_workspace_dataplane_artifacts_api_v2_experimental_workspaces_workspace_id_dataplane_artifacts_get_with_http_info(workspace_id, **kwargs)  # noqa: E501
+        return self.get_workos_authorize_url_api_v2_workos_authorize_get_with_http_info(**kwargs)  # noqa: E501
 
-    def get_workspace_dataplane_artifacts_api_v2_experimental_workspaces_workspace_id_dataplane_artifacts_get_with_http_info(self, workspace_id, **kwargs):  # noqa: E501
-        """Get Workspace Dataplane Artifacts  # noqa: E501
+    def get_workos_authorize_url_api_v2_workos_authorize_get_with_http_info(self, **kwargs):  # noqa: E501
+        """Get Workos Authorize Url  # noqa: E501
 
-        Retrieve workspace dataplane artifacts.  # 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_workspace_dataplane_artifacts_api_v2_experimental_workspaces_workspace_id_dataplane_artifacts_get_with_http_info(workspace_id, async_req=True)
+        >>> thread = api.get_workos_authorize_url_api_v2_workos_authorize_get_with_http_info(async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str workspace_id: ID of the Workspace to retrieve. (required)
-        :param CloudDataBucketAccessMode access_mode: Access mode for the workspace artifacts.
+        :param str email_address:
+        :param str provider:
         :param _return_http_data_only: response data without head status code
                                        and headers
         :param _preload_content: if False, the urllib3.HTTPResponse object will
@@ -21603,7 +22345,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(WorkspacedataplaneartifactsResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(WorkosauthorizeurlresponseResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -21611,8 +22353,8 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'workspace_id',
-            'access_mode'
+            'email_address',
+            'provider'
         ]
         all_params.extend(
             [
@@ -21627,7 +22369,236 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_workspace_dataplane_artifacts_api_v2_experimental_workspaces_workspace_id_dataplane_artifacts_get" % key
+                    " to method get_workos_authorize_url_api_v2_workos_authorize_get" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+        if 'email_address' in local_var_params and local_var_params['email_address'] is not None:  # noqa: E501
+            query_params.append(('email_address', local_var_params['email_address']))  # noqa: E501
+        if 'provider' in local_var_params and local_var_params['provider'] is not None:  # noqa: E501
+            query_params.append(('provider', local_var_params['provider']))  # 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/workos/authorize', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='WorkosauthorizeurlresponseResponse',  # 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_workspace_api_v2_experimental_workspaces_workspace_id_get(self, workspace_id, **kwargs):  # noqa: E501
+        """Get Workspace  # noqa: E501
+
+        Retrieves a Workspace.  # 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_workspace_api_v2_experimental_workspaces_workspace_id_get(workspace_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str workspace_id: ID of the Workspace to retreive. (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.get_workspace_api_v2_experimental_workspaces_workspace_id_get_with_http_info(workspace_id, **kwargs)  # noqa: E501
+
+    def get_workspace_api_v2_experimental_workspaces_workspace_id_get_with_http_info(self, workspace_id, **kwargs):  # noqa: E501
+        """Get Workspace  # noqa: E501
+
+        Retrieves a Workspace.  # 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_workspace_api_v2_experimental_workspaces_workspace_id_get_with_http_info(workspace_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str workspace_id: ID of the Workspace to retreive. (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 = [
+            'workspace_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_workspace_api_v2_experimental_workspaces_workspace_id_get" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'workspace_id' is set
+        if self.api_client.client_side_validation and ('workspace_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['workspace_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `workspace_id` when calling `get_workspace_api_v2_experimental_workspaces_workspace_id_get`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'workspace_id' in local_var_params:
+            path_params['workspace_id'] = local_var_params['workspace_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/experimental_workspaces/{workspace_id}', 'GET',
+            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 get_workspace_dataplane_artifacts_api_v2_experimental_workspaces_workspace_id_dataplane_artifacts_get(self, workspace_id, **kwargs):  # noqa: E501
+        """Get Workspace Dataplane Artifacts  # noqa: E501
+
+        Retrieve workspace dataplane artifacts.  # 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_workspace_dataplane_artifacts_api_v2_experimental_workspaces_workspace_id_dataplane_artifacts_get(workspace_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str workspace_id: ID of the Workspace to retrieve. (required)
+        :param CloudDataBucketAccessMode access_mode: Access mode for the workspace artifacts.
+        :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: WorkspacedataplaneartifactsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.get_workspace_dataplane_artifacts_api_v2_experimental_workspaces_workspace_id_dataplane_artifacts_get_with_http_info(workspace_id, **kwargs)  # noqa: E501
+
+    def get_workspace_dataplane_artifacts_api_v2_experimental_workspaces_workspace_id_dataplane_artifacts_get_with_http_info(self, workspace_id, **kwargs):  # noqa: E501
+        """Get Workspace Dataplane Artifacts  # noqa: E501
+
+        Retrieve workspace dataplane artifacts.  # 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_workspace_dataplane_artifacts_api_v2_experimental_workspaces_workspace_id_dataplane_artifacts_get_with_http_info(workspace_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str workspace_id: ID of the Workspace to retrieve. (required)
+        :param CloudDataBucketAccessMode access_mode: Access mode for the workspace artifacts.
+        :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(WorkspacedataplaneartifactsResponse, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'workspace_id',
+            'access_mode'
+        ]
+        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_workspace_dataplane_artifacts_api_v2_experimental_workspaces_workspace_id_dataplane_artifacts_get" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
@@ -24250,6 +25221,7 @@ class DefaultApi(object):
         :param str source_cron_job_id: filter by cron_job_id id
         :param ArchiveStatus archive_status: The archive status to filter by. Defaults to unarchived.
         :param str cloud_id: cloud_id to filter by
+        :param list[str] tag_filter: Repeatable filter of tags in the form key:value. Can be specified multiple times. Values with the same key are ORed; keys are ANDed.
         :param HaJobsSortField sort_field: If absent, the sort order will be determined according to the type_filter.
         :param SortOrder sort_order: If sort_field is absent, this field is ignored.If absent, this field defaults to ascending.
         :param str paging_token:
@@ -24286,6 +25258,7 @@ class DefaultApi(object):
         :param str source_cron_job_id: filter by cron_job_id id
         :param ArchiveStatus archive_status: The archive status to filter by. Defaults to unarchived.
         :param str cloud_id: cloud_id to filter by
+        :param list[str] tag_filter: Repeatable filter of tags in the form key:value. Can be specified multiple times. Values with the same key are ORed; keys are ANDed.
         :param HaJobsSortField sort_field: If absent, the sort order will be determined according to the type_filter.
         :param SortOrder sort_order: If sort_field is absent, this field is ignored.If absent, this field defaults to ascending.
         :param str paging_token:
@@ -24316,6 +25289,7 @@ class DefaultApi(object):
             'source_cron_job_id',
             'archive_status',
             'cloud_id',
+            'tag_filter',
             'sort_field',
             'sort_order',
             'paging_token',
@@ -24367,6 +25341,9 @@ class DefaultApi(object):
             query_params.append(('archive_status', local_var_params['archive_status']))  # noqa: E501
         if 'cloud_id' in local_var_params and local_var_params['cloud_id'] is not None:  # noqa: E501
             query_params.append(('cloud_id', local_var_params['cloud_id']))  # noqa: E501
+        if 'tag_filter' in local_var_params and local_var_params['tag_filter'] is not None:  # noqa: E501
+            query_params.append(('tag_filter', local_var_params['tag_filter']))  # noqa: E501
+            collection_formats['tag_filter'] = 'multi'  # noqa: E501
         if 'sort_field' in local_var_params and local_var_params['sort_field'] is not None:  # noqa: E501
             query_params.append(('sort_field', local_var_params['sort_field']))  # noqa: E501
         if 'sort_order' in local_var_params and local_var_params['sort_order'] is not None:  # noqa: E501
@@ -25336,21 +26313,18 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def list_long_running_workloads_api_v2_decorated_sessions_long_running_workloads_get(self, **kwargs):  # noqa: E501
-        """List Long Running Workloads  # noqa: E501
+    def list_keys_api_v2_tags_keys_get(self, **kwargs):  # noqa: E501
+        """List Keys  # noqa: E501
 
-        Lists long running workloads within a cloud or organization, sorted by duration.  # 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_long_running_workloads_api_v2_decorated_sessions_long_running_workloads_get(async_req=True)
+        >>> thread = api.list_keys_api_v2_tags_keys_get(async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str cloud_id: The cloud ID to filter by.
-        :param str project_id: The project ID to filter by.
-        :param bool jobs_only: Whether to only include jobs.
-        :param bool workspaces_only: Whether to only include workspaces.
-        :param int duration_s: The duration in seconds to filter by. Defaults to 24 hours.
+        :param ResourceTagResourceType resource_type:
+        :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.
@@ -25358,28 +26332,25 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: LongrunningworkloadListResponse
+        :return: TagkeyListResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.list_long_running_workloads_api_v2_decorated_sessions_long_running_workloads_get_with_http_info(**kwargs)  # noqa: E501
+        return self.list_keys_api_v2_tags_keys_get_with_http_info(**kwargs)  # noqa: E501
 
-    def list_long_running_workloads_api_v2_decorated_sessions_long_running_workloads_get_with_http_info(self, **kwargs):  # noqa: E501
-        """List Long Running Workloads  # noqa: E501
+    def list_keys_api_v2_tags_keys_get_with_http_info(self, **kwargs):  # noqa: E501
+        """List Keys  # noqa: E501
 
-        Lists long running workloads within a cloud or organization, sorted by duration.  # 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_long_running_workloads_api_v2_decorated_sessions_long_running_workloads_get_with_http_info(async_req=True)
+        >>> thread = api.list_keys_api_v2_tags_keys_get_with_http_info(async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str cloud_id: The cloud ID to filter by.
-        :param str project_id: The project ID to filter by.
-        :param bool jobs_only: Whether to only include jobs.
-        :param bool workspaces_only: Whether to only include workspaces.
-        :param int duration_s: The duration in seconds to filter by. Defaults to 24 hours.
+        :param ResourceTagResourceType resource_type:
+        :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
@@ -25389,7 +26360,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(LongrunningworkloadListResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(TagkeyListResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -25397,12 +26368,140 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'cloud_id',
-            'project_id',
-            'jobs_only',
-            'workspaces_only',
-            'duration_s'
-        ]
+            'resource_type',
+            '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 list_keys_api_v2_tags_keys_get" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+
+        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 `list_keys_api_v2_tags_keys_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 `list_keys_api_v2_tags_keys_get`, must be a value greater than or equal to `0`")  # noqa: E501
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+        if 'resource_type' in local_var_params and local_var_params['resource_type'] is not None:  # noqa: E501
+            query_params.append(('resource_type', local_var_params['resource_type']))  # 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/tags/keys', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='TagkeyListResponse',  # 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_long_running_workloads_api_v2_decorated_sessions_long_running_workloads_get(self, **kwargs):  # noqa: E501
+        """List Long Running Workloads  # noqa: E501
+
+        Lists long running workloads within a cloud or organization, sorted by duration.  # 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_long_running_workloads_api_v2_decorated_sessions_long_running_workloads_get(async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str cloud_id: The cloud ID to filter by.
+        :param str project_id: The project ID to filter by.
+        :param bool jobs_only: Whether to only include jobs.
+        :param bool workspaces_only: Whether to only include workspaces.
+        :param int duration_s: The duration in seconds to filter by. Defaults to 24 hours.
+        :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: LongrunningworkloadListResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.list_long_running_workloads_api_v2_decorated_sessions_long_running_workloads_get_with_http_info(**kwargs)  # noqa: E501
+
+    def list_long_running_workloads_api_v2_decorated_sessions_long_running_workloads_get_with_http_info(self, **kwargs):  # noqa: E501
+        """List Long Running Workloads  # noqa: E501
+
+        Lists long running workloads within a cloud or organization, sorted by duration.  # 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_long_running_workloads_api_v2_decorated_sessions_long_running_workloads_get_with_http_info(async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str cloud_id: The cloud ID to filter by.
+        :param str project_id: The project ID to filter by.
+        :param bool jobs_only: Whether to only include jobs.
+        :param bool workspaces_only: Whether to only include workspaces.
+        :param int duration_s: The duration in seconds to filter by. Defaults to 24 hours.
+        :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(LongrunningworkloadListResponse, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'cloud_id',
+            'project_id',
+            'jobs_only',
+            'workspaces_only',
+            'duration_s'
+        ]
         all_params.extend(
             [
                 'async_req',
@@ -26479,7 +27578,7 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: WorkspacetemplateListResponse
+        :return: GlobalworkspacetemplateListResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -26508,7 +27607,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(WorkspacetemplateListResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(GlobalworkspacetemplateListResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -26572,7 +27671,7 @@ class DefaultApi(object):
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='WorkspacetemplateListResponse',  # noqa: E501
+            response_type='GlobalworkspacetemplateListResponse',  # 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
@@ -26596,6 +27695,7 @@ class DefaultApi(object):
         :param str creator_id: creator_id to filter by
         :param str cloud_id: cloud_id to filter by
         :param list[ApplicationType] application_type: Application type to filter by
+        :param list[str] tag_filter: Repeatable filter of tags in the form key:value. Can be specified multiple times. Values with the same key are ORed; keys are ANDed.
         :param ServiceSortField sort_field: If absent, the default sorting order is 1. status (active first).2. Last updated at (desc). 3. Name (asc).
         :param SortOrder sort_order: If sort_field is absent, this field is ignored.If absent, this field defaults to ascending.
         :param str paging_token:
@@ -26630,6 +27730,7 @@ class DefaultApi(object):
         :param str creator_id: creator_id to filter by
         :param str cloud_id: cloud_id to filter by
         :param list[ApplicationType] application_type: Application type to filter by
+        :param list[str] tag_filter: Repeatable filter of tags in the form key:value. Can be specified multiple times. Values with the same key are ORed; keys are ANDed.
         :param ServiceSortField sort_field: If absent, the default sorting order is 1. status (active first).2. Last updated at (desc). 3. Name (asc).
         :param SortOrder sort_order: If sort_field is absent, this field is ignored.If absent, this field defaults to ascending.
         :param str paging_token:
@@ -26658,6 +27759,7 @@ class DefaultApi(object):
             'creator_id',
             'cloud_id',
             'application_type',
+            'tag_filter',
             'sort_field',
             'sort_order',
             'paging_token',
@@ -26706,6 +27808,9 @@ class DefaultApi(object):
         if 'application_type' in local_var_params and local_var_params['application_type'] is not None:  # noqa: E501
             query_params.append(('application_type', local_var_params['application_type']))  # noqa: E501
             collection_formats['application_type'] = 'multi'  # noqa: E501
+        if 'tag_filter' in local_var_params and local_var_params['tag_filter'] is not None:  # noqa: E501
+            query_params.append(('tag_filter', local_var_params['tag_filter']))  # noqa: E501
+            collection_formats['tag_filter'] = 'multi'  # noqa: E501
         if 'sort_field' in local_var_params and local_var_params['sort_field'] is not None:  # noqa: E501
             query_params.append(('sort_field', local_var_params['sort_field']))  # noqa: E501
         if 'sort_order' in local_var_params and local_var_params['sort_order'] is not None:  # noqa: E501
@@ -26893,21 +27998,17 @@ class DefaultApi(object):
             _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
+    def list_template_versions_api_v2_workspace_templates_template_id_versions_get(self, template_id, **kwargs):  # noqa: E501
+        """List Template Versions  # noqa: E501
 
-        Lists all workspace templates  # noqa: E501
+        List versions for a workspace template  # 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_workspace_templates_api_v2_experimental_workspaces_templates_get(async_req=True)
+        >>> thread = api.list_template_versions_api_v2_workspace_templates_template_id_versions_get(template_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param list[str] oa_group_names: Search for workspaces that belong to the provided group name
-        :param bool for_private_endpoints_homepage: Filters the list to be ones expected for private endpoints home page
-        :param bool for_fine_tuning: Filters the list to be ones expected for fine tuning tutorial section
-        :param bool for_ai_apps_section: Filters the list to show the ones expected for ai apps section
-        :param bool for_gallery: Filters the list to show the ones expected for gallery section
+        :param str template_id: (required)
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -26915,28 +28016,24 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: WorkspacetemplateListResponse
+        :return: WorkspacetemplateversionListResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.list_workspace_templates_api_v2_experimental_workspaces_templates_get_with_http_info(**kwargs)  # noqa: E501
+        return self.list_template_versions_api_v2_workspace_templates_template_id_versions_get_with_http_info(template_id, **kwargs)  # noqa: E501
 
-    def list_workspace_templates_api_v2_experimental_workspaces_templates_get_with_http_info(self, **kwargs):  # noqa: E501
-        """List Workspace Templates  # noqa: E501
+    def list_template_versions_api_v2_workspace_templates_template_id_versions_get_with_http_info(self, template_id, **kwargs):  # noqa: E501
+        """List Template Versions  # noqa: E501
 
-        Lists all workspace templates  # noqa: E501
+        List versions for a workspace template  # 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_workspace_templates_api_v2_experimental_workspaces_templates_get_with_http_info(async_req=True)
+        >>> thread = api.list_template_versions_api_v2_workspace_templates_template_id_versions_get_with_http_info(template_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param list[str] oa_group_names: Search for workspaces that belong to the provided group name
-        :param bool for_private_endpoints_homepage: Filters the list to be ones expected for private endpoints home page
-        :param bool for_fine_tuning: Filters the list to be ones expected for fine tuning tutorial section
-        :param bool for_ai_apps_section: Filters the list to show the ones expected for ai apps section
-        :param bool for_gallery: Filters the list to show the ones expected for gallery section
+        :param str template_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
@@ -26946,7 +28043,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(WorkspacetemplateListResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(WorkspacetemplateversionListResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -26954,11 +28051,7 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'oa_group_names',
-            'for_private_endpoints_homepage',
-            'for_fine_tuning',
-            'for_ai_apps_section',
-            'for_gallery'
+            'template_id'
         ]
         all_params.extend(
             [
@@ -26973,27 +28066,22 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_workspace_templates_api_v2_experimental_workspaces_templates_get" % key
+                    " to method list_template_versions_api_v2_workspace_templates_template_id_versions_get" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
+        # verify the required parameter 'template_id' is set
+        if self.api_client.client_side_validation and ('template_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['template_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `template_id` when calling `list_template_versions_api_v2_workspace_templates_template_id_versions_get`")  # noqa: E501
 
         collection_formats = {}
 
         path_params = {}
+        if 'template_id' in local_var_params:
+            path_params['template_id'] = local_var_params['template_id']  # noqa: E501
 
         query_params = []
-        if 'oa_group_names' in local_var_params and local_var_params['oa_group_names'] is not None:  # noqa: E501
-            query_params.append(('oa_group_names', local_var_params['oa_group_names']))  # noqa: E501
-            collection_formats['oa_group_names'] = 'multi'  # noqa: E501
-        if 'for_private_endpoints_homepage' in local_var_params and local_var_params['for_private_endpoints_homepage'] is not None:  # noqa: E501
-            query_params.append(('for_private_endpoints_homepage', local_var_params['for_private_endpoints_homepage']))  # noqa: E501
-        if 'for_fine_tuning' in local_var_params and local_var_params['for_fine_tuning'] is not None:  # noqa: E501
-            query_params.append(('for_fine_tuning', local_var_params['for_fine_tuning']))  # noqa: E501
-        if 'for_ai_apps_section' in local_var_params and local_var_params['for_ai_apps_section'] is not None:  # noqa: E501
-            query_params.append(('for_ai_apps_section', local_var_params['for_ai_apps_section']))  # noqa: E501
-        if 'for_gallery' in local_var_params and local_var_params['for_gallery'] is not None:  # noqa: E501
-            query_params.append(('for_gallery', local_var_params['for_gallery']))  # noqa: E501
 
         header_params = {}
 
@@ -27009,14 +28097,14 @@ class DefaultApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/api/v2/experimental_workspaces/templates', 'GET',
+            '/api/v2/workspace_templates/{template_id}/versions', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='WorkspacetemplateListResponse',  # noqa: E501
+            response_type='WorkspacetemplateversionListResponse',  # 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
@@ -27024,26 +28112,29 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def list_workspaces_api_v2_experimental_workspaces_get(self, **kwargs):  # noqa: E501
-        """List Workspaces  # noqa: E501
+    def list_templates_api_v2_workspace_templates_get(self, **kwargs):  # noqa: E501
+        """List Templates  # noqa: E501
 
-        Lists all Workspace the user has access to  # noqa: E501
+        List user's workspace templates with pagination, filtering, and search  # 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_workspaces_api_v2_experimental_workspaces_get(async_req=True)
+        >>> thread = api.list_templates_api_v2_workspace_templates_get(async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str name: Search for workspace with a name that equals the provided value
-        :param str name_contains: Search for workspace with a name that contains the provided value
-        :param str creator_id: List workspaces created by a given user
-        :param str project_id: Search for workspace with project_id
-        :param str cloud_id: Search for workspace with cloud_id
-        :param list[SessionState] state_filter: A list of session states to filter by
-        :param ExperimentalWorkspacesSortField sort_field: If absent, the sort order will be determined according to the type_filter.
-        :param SortOrder sort_order: If sort_field is absent, this field is ignored.If absent, this field defaults to ascending.
+        :param str name: Filter by template name (partial match)
+        :param str text_contains: Filter by template name, description, or labels (partial match)
+        :param WorkspaceTemplateComplexity complexity: Filter by complexity level
+        :param WorkspaceTemplateCategory category: Filter by category
+        :param str labels: Comma-separated list of labels to filter by
+        :param str cloud_id: Filter by cloud ID
+        :param bool is_global: Filter by global templates
+        :param str creator_id: Filter by creator user ID
+        :param PublishedFilter published: Filter by published templates
         :param str paging_token:
         :param int count:
+        :param WorkspaceTemplatesSortField sort_field: If absent, the sort order will be determined according to the type_filter.
+        :param SortOrder sort_order: If sort_field is absent, this field is ignored.If absent, this field defaults to ascending.
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -27051,33 +28142,36 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: ExperimentalworkspaceListResponse
+        :return: WorkspacetemplateListResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.list_workspaces_api_v2_experimental_workspaces_get_with_http_info(**kwargs)  # noqa: E501
+        return self.list_templates_api_v2_workspace_templates_get_with_http_info(**kwargs)  # noqa: E501
 
-    def list_workspaces_api_v2_experimental_workspaces_get_with_http_info(self, **kwargs):  # noqa: E501
-        """List Workspaces  # noqa: E501
+    def list_templates_api_v2_workspace_templates_get_with_http_info(self, **kwargs):  # noqa: E501
+        """List Templates  # noqa: E501
 
-        Lists all Workspace the user has access to  # noqa: E501
+        List user's workspace templates with pagination, filtering, and search  # 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_workspaces_api_v2_experimental_workspaces_get_with_http_info(async_req=True)
+        >>> thread = api.list_templates_api_v2_workspace_templates_get_with_http_info(async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param str name: Search for workspace with a name that equals the provided value
-        :param str name_contains: Search for workspace with a name that contains the provided value
-        :param str creator_id: List workspaces created by a given user
-        :param str project_id: Search for workspace with project_id
-        :param str cloud_id: Search for workspace with cloud_id
-        :param list[SessionState] state_filter: A list of session states to filter by
-        :param ExperimentalWorkspacesSortField sort_field: If absent, the sort order will be determined according to the type_filter.
-        :param SortOrder sort_order: If sort_field is absent, this field is ignored.If absent, this field defaults to ascending.
+        :param str name: Filter by template name (partial match)
+        :param str text_contains: Filter by template name, description, or labels (partial match)
+        :param WorkspaceTemplateComplexity complexity: Filter by complexity level
+        :param WorkspaceTemplateCategory category: Filter by category
+        :param str labels: Comma-separated list of labels to filter by
+        :param str cloud_id: Filter by cloud ID
+        :param bool is_global: Filter by global templates
+        :param str creator_id: Filter by creator user ID
+        :param PublishedFilter published: Filter by published templates
         :param str paging_token:
         :param int count:
+        :param WorkspaceTemplatesSortField sort_field: If absent, the sort order will be determined according to the type_filter.
+        :param SortOrder sort_order: If sort_field is absent, this field is ignored.If absent, this field defaults to ascending.
         :param _return_http_data_only: response data without head status code
                                        and headers
         :param _preload_content: if False, the urllib3.HTTPResponse object will
@@ -27087,7 +28181,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(ExperimentalworkspaceListResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(WorkspacetemplateListResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -27096,15 +28190,18 @@ class DefaultApi(object):
 
         all_params = [
             'name',
-            'name_contains',
-            'creator_id',
-            'project_id',
+            'text_contains',
+            'complexity',
+            'category',
+            'labels',
             'cloud_id',
-            'state_filter',
-            'sort_field',
-            'sort_order',
+            'is_global',
+            'creator_id',
+            'published',
             'paging_token',
-            'count'
+            'count',
+            'sort_field',
+            'sort_order'
         ]
         all_params.extend(
             [
@@ -27119,15 +28216,15 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method list_workspaces_api_v2_experimental_workspaces_get" % key
+                    " to method list_templates_api_v2_workspace_templates_get" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
 
-        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 `list_workspaces_api_v2_experimental_workspaces_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'] > 1000:  # noqa: E501
+            raise ApiValueError("Invalid value for parameter `count` when calling `list_templates_api_v2_workspace_templates_get`, must be a value less than or equal to `1000`")  # 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 `list_workspaces_api_v2_experimental_workspaces_get`, must be a value greater than or equal to `0`")  # noqa: E501
+            raise ApiValueError("Invalid value for parameter `count` when calling `list_templates_api_v2_workspace_templates_get`, must be a value greater than or equal to `0`")  # noqa: E501
         collection_formats = {}
 
         path_params = {}
@@ -27135,25 +28232,30 @@ class DefaultApi(object):
         query_params = []
         if 'name' in local_var_params and local_var_params['name'] is not None:  # noqa: E501
             query_params.append(('name', local_var_params['name']))  # noqa: E501
-        if 'name_contains' in local_var_params and local_var_params['name_contains'] is not None:  # noqa: E501
-            query_params.append(('name_contains', local_var_params['name_contains']))  # noqa: E501
-        if 'creator_id' in local_var_params and local_var_params['creator_id'] is not None:  # noqa: E501
-            query_params.append(('creator_id', local_var_params['creator_id']))  # noqa: E501
-        if 'project_id' in local_var_params and local_var_params['project_id'] is not None:  # noqa: E501
-            query_params.append(('project_id', local_var_params['project_id']))  # noqa: E501
+        if 'text_contains' in local_var_params and local_var_params['text_contains'] is not None:  # noqa: E501
+            query_params.append(('text_contains', local_var_params['text_contains']))  # noqa: E501
+        if 'complexity' in local_var_params and local_var_params['complexity'] is not None:  # noqa: E501
+            query_params.append(('complexity', local_var_params['complexity']))  # noqa: E501
+        if 'category' in local_var_params and local_var_params['category'] is not None:  # noqa: E501
+            query_params.append(('category', local_var_params['category']))  # noqa: E501
+        if 'labels' in local_var_params and local_var_params['labels'] is not None:  # noqa: E501
+            query_params.append(('labels', local_var_params['labels']))  # noqa: E501
         if 'cloud_id' in local_var_params and local_var_params['cloud_id'] is not None:  # noqa: E501
             query_params.append(('cloud_id', local_var_params['cloud_id']))  # noqa: E501
-        if 'state_filter' in local_var_params and local_var_params['state_filter'] is not None:  # noqa: E501
-            query_params.append(('state_filter', local_var_params['state_filter']))  # noqa: E501
-            collection_formats['state_filter'] = 'multi'  # noqa: E501
-        if 'sort_field' in local_var_params and local_var_params['sort_field'] is not None:  # noqa: E501
-            query_params.append(('sort_field', local_var_params['sort_field']))  # noqa: E501
-        if 'sort_order' in local_var_params and local_var_params['sort_order'] is not None:  # noqa: E501
-            query_params.append(('sort_order', local_var_params['sort_order']))  # noqa: E501
+        if 'is_global' in local_var_params and local_var_params['is_global'] is not None:  # noqa: E501
+            query_params.append(('is_global', local_var_params['is_global']))  # noqa: E501
+        if 'creator_id' in local_var_params and local_var_params['creator_id'] is not None:  # noqa: E501
+            query_params.append(('creator_id', local_var_params['creator_id']))  # noqa: E501
+        if 'published' in local_var_params and local_var_params['published'] is not None:  # noqa: E501
+            query_params.append(('published', local_var_params['published']))  # 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
+        if 'sort_field' in local_var_params and local_var_params['sort_field'] is not None:  # noqa: E501
+            query_params.append(('sort_field', local_var_params['sort_field']))  # noqa: E501
+        if 'sort_order' in local_var_params and local_var_params['sort_order'] is not None:  # noqa: E501
+            query_params.append(('sort_order', local_var_params['sort_order']))  # noqa: E501
 
         header_params = {}
 
@@ -27169,14 +28271,14 @@ class DefaultApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/api/v2/experimental_workspaces/', 'GET',
+            '/api/v2/workspace_templates/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='ExperimentalworkspaceListResponse',  # noqa: E501
+            response_type='WorkspacetemplateListResponse',  # 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
@@ -27184,16 +28286,19 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def login_user_api_v2_users_login_post(self, login_user_params, **kwargs):  # noqa: E501
-        """Login User  # noqa: E501
+    def list_values_api_v2_tags_values_get(self, key, **kwargs):  # noqa: E501
+        """List Values  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.login_user_api_v2_users_login_post(login_user_params, async_req=True)
+        >>> thread = api.list_values_api_v2_tags_values_get(key, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param LoginUserParams login_user_params: (required)
+        :param str key: (required)
+        :param ResourceTagResourceType resource_type:
+        :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.
@@ -27201,19 +28306,444 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: None
+        :return: TagvalueListResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.login_user_api_v2_users_login_post_with_http_info(login_user_params, **kwargs)  # noqa: E501
+        return self.list_values_api_v2_tags_values_get_with_http_info(key, **kwargs)  # noqa: E501
 
-    def login_user_api_v2_users_login_post_with_http_info(self, login_user_params, **kwargs):  # noqa: E501
-        """Login User  # noqa: E501
+    def list_values_api_v2_tags_values_get_with_http_info(self, key, **kwargs):  # noqa: E501
+        """List Values  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.login_user_api_v2_users_login_post_with_http_info(login_user_params, async_req=True)
+        >>> thread = api.list_values_api_v2_tags_values_get_with_http_info(key, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str key: (required)
+        :param ResourceTagResourceType resource_type:
+        :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(TagvalueListResponse, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'key',
+            'resource_type',
+            '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 list_values_api_v2_tags_values_get" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'key' is set
+        if self.api_client.client_side_validation and ('key' not in local_var_params or  # noqa: E501
+                                                        local_var_params['key'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `key` when calling `list_values_api_v2_tags_values_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 `list_values_api_v2_tags_values_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 `list_values_api_v2_tags_values_get`, must be a value greater than or equal to `0`")  # noqa: E501
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+        if 'key' in local_var_params and local_var_params['key'] is not None:  # noqa: E501
+            query_params.append(('key', local_var_params['key']))  # noqa: E501
+        if 'resource_type' in local_var_params and local_var_params['resource_type'] is not None:  # noqa: E501
+            query_params.append(('resource_type', local_var_params['resource_type']))  # 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/tags/values', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='TagvalueListResponse',  # 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
+
+        Lists all workspace templates  # 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_workspace_templates_api_v2_experimental_workspaces_templates_get(async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param list[str] oa_group_names: Search for workspaces that belong to the provided group name
+        :param bool for_private_endpoints_homepage: Filters the list to be ones expected for private endpoints home page
+        :param bool for_fine_tuning: Filters the list to be ones expected for fine tuning tutorial section
+        :param bool for_ai_apps_section: Filters the list to show the ones expected for ai apps section
+        :param bool for_gallery: Filters the list to show the ones expected for gallery section
+        :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: GlobalworkspacetemplateListResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.list_workspace_templates_api_v2_experimental_workspaces_templates_get_with_http_info(**kwargs)  # noqa: E501
+
+    def list_workspace_templates_api_v2_experimental_workspaces_templates_get_with_http_info(self, **kwargs):  # noqa: E501
+        """List Workspace Templates  # noqa: E501
+
+        Lists all workspace templates  # 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_workspace_templates_api_v2_experimental_workspaces_templates_get_with_http_info(async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param list[str] oa_group_names: Search for workspaces that belong to the provided group name
+        :param bool for_private_endpoints_homepage: Filters the list to be ones expected for private endpoints home page
+        :param bool for_fine_tuning: Filters the list to be ones expected for fine tuning tutorial section
+        :param bool for_ai_apps_section: Filters the list to show the ones expected for ai apps section
+        :param bool for_gallery: Filters the list to show the ones expected for gallery section
+        :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(GlobalworkspacetemplateListResponse, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'oa_group_names',
+            'for_private_endpoints_homepage',
+            'for_fine_tuning',
+            'for_ai_apps_section',
+            'for_gallery'
+        ]
+        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_workspace_templates_api_v2_experimental_workspaces_templates_get" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+        if 'oa_group_names' in local_var_params and local_var_params['oa_group_names'] is not None:  # noqa: E501
+            query_params.append(('oa_group_names', local_var_params['oa_group_names']))  # noqa: E501
+            collection_formats['oa_group_names'] = 'multi'  # noqa: E501
+        if 'for_private_endpoints_homepage' in local_var_params and local_var_params['for_private_endpoints_homepage'] is not None:  # noqa: E501
+            query_params.append(('for_private_endpoints_homepage', local_var_params['for_private_endpoints_homepage']))  # noqa: E501
+        if 'for_fine_tuning' in local_var_params and local_var_params['for_fine_tuning'] is not None:  # noqa: E501
+            query_params.append(('for_fine_tuning', local_var_params['for_fine_tuning']))  # noqa: E501
+        if 'for_ai_apps_section' in local_var_params and local_var_params['for_ai_apps_section'] is not None:  # noqa: E501
+            query_params.append(('for_ai_apps_section', local_var_params['for_ai_apps_section']))  # noqa: E501
+        if 'for_gallery' in local_var_params and local_var_params['for_gallery'] is not None:  # noqa: E501
+            query_params.append(('for_gallery', local_var_params['for_gallery']))  # 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/experimental_workspaces/templates', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='GlobalworkspacetemplateListResponse',  # 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_workspaces_api_v2_experimental_workspaces_get(self, **kwargs):  # noqa: E501
+        """List Workspaces  # noqa: E501
+
+        Lists all Workspace the user has access to  # 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_workspaces_api_v2_experimental_workspaces_get(async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str name: Search for workspace with a name that equals the provided value
+        :param str name_contains: Search for workspace with a name that contains the provided value
+        :param str creator_id: List workspaces created by a given user
+        :param str project_id: Search for workspace with project_id
+        :param str cloud_id: Search for workspace with cloud_id
+        :param list[SessionState] state_filter: A list of session states to filter by
+        :param list[str] tag_filter: Repeatable filter of tags in the form key:value. Can be specified multiple times. Values with the same key are ORed; keys are ANDed.
+        :param ExperimentalWorkspacesSortField sort_field: If absent, the sort order will be determined according to the type_filter.
+        :param SortOrder sort_order: If sort_field is absent, this field is ignored.If absent, this field defaults to ascending.
+        :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: ExperimentalworkspaceListResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.list_workspaces_api_v2_experimental_workspaces_get_with_http_info(**kwargs)  # noqa: E501
+
+    def list_workspaces_api_v2_experimental_workspaces_get_with_http_info(self, **kwargs):  # noqa: E501
+        """List Workspaces  # noqa: E501
+
+        Lists all Workspace the user has access to  # 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_workspaces_api_v2_experimental_workspaces_get_with_http_info(async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str name: Search for workspace with a name that equals the provided value
+        :param str name_contains: Search for workspace with a name that contains the provided value
+        :param str creator_id: List workspaces created by a given user
+        :param str project_id: Search for workspace with project_id
+        :param str cloud_id: Search for workspace with cloud_id
+        :param list[SessionState] state_filter: A list of session states to filter by
+        :param list[str] tag_filter: Repeatable filter of tags in the form key:value. Can be specified multiple times. Values with the same key are ORed; keys are ANDed.
+        :param ExperimentalWorkspacesSortField sort_field: If absent, the sort order will be determined according to the type_filter.
+        :param SortOrder sort_order: If sort_field is absent, this field is ignored.If absent, this field defaults to ascending.
+        :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(ExperimentalworkspaceListResponse, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'name',
+            'name_contains',
+            'creator_id',
+            'project_id',
+            'cloud_id',
+            'state_filter',
+            'tag_filter',
+            'sort_field',
+            'sort_order',
+            '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 list_workspaces_api_v2_experimental_workspaces_get" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+
+        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 `list_workspaces_api_v2_experimental_workspaces_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 `list_workspaces_api_v2_experimental_workspaces_get`, must be a value greater than or equal to `0`")  # noqa: E501
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+        if 'name' in local_var_params and local_var_params['name'] is not None:  # noqa: E501
+            query_params.append(('name', local_var_params['name']))  # noqa: E501
+        if 'name_contains' in local_var_params and local_var_params['name_contains'] is not None:  # noqa: E501
+            query_params.append(('name_contains', local_var_params['name_contains']))  # noqa: E501
+        if 'creator_id' in local_var_params and local_var_params['creator_id'] is not None:  # noqa: E501
+            query_params.append(('creator_id', local_var_params['creator_id']))  # noqa: E501
+        if 'project_id' in local_var_params and local_var_params['project_id'] is not None:  # noqa: E501
+            query_params.append(('project_id', local_var_params['project_id']))  # noqa: E501
+        if 'cloud_id' in local_var_params and local_var_params['cloud_id'] is not None:  # noqa: E501
+            query_params.append(('cloud_id', local_var_params['cloud_id']))  # noqa: E501
+        if 'state_filter' in local_var_params and local_var_params['state_filter'] is not None:  # noqa: E501
+            query_params.append(('state_filter', local_var_params['state_filter']))  # noqa: E501
+            collection_formats['state_filter'] = 'multi'  # noqa: E501
+        if 'tag_filter' in local_var_params and local_var_params['tag_filter'] is not None:  # noqa: E501
+            query_params.append(('tag_filter', local_var_params['tag_filter']))  # noqa: E501
+            collection_formats['tag_filter'] = 'multi'  # noqa: E501
+        if 'sort_field' in local_var_params and local_var_params['sort_field'] is not None:  # noqa: E501
+            query_params.append(('sort_field', local_var_params['sort_field']))  # noqa: E501
+        if 'sort_order' in local_var_params and local_var_params['sort_order'] is not None:  # noqa: E501
+            query_params.append(('sort_order', local_var_params['sort_order']))  # 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/experimental_workspaces/', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='ExperimentalworkspaceListResponse',  # 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 login_user_api_v2_users_login_post(self, login_user_params, **kwargs):  # noqa: E501
+        """Login User  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.login_user_api_v2_users_login_post(login_user_params, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param LoginUserParams login_user_params: (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.login_user_api_v2_users_login_post_with_http_info(login_user_params, **kwargs)  # noqa: E501
+
+    def login_user_api_v2_users_login_post_with_http_info(self, login_user_params, **kwargs):  # noqa: E501
+        """Login User  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.login_user_api_v2_users_login_post_with_http_info(login_user_params, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
@@ -27891,6 +29421,129 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
+    def publish_version_api_v2_workspace_templates_template_id_versions_version_id_publish_post(self, template_id, version_id, **kwargs):  # noqa: E501
+        """Publish Version  # noqa: E501
+
+        Publish a version as the active version for a template  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.publish_version_api_v2_workspace_templates_template_id_versions_version_id_publish_post(template_id, version_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str template_id: (required)
+        :param str version_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: object
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.publish_version_api_v2_workspace_templates_template_id_versions_version_id_publish_post_with_http_info(template_id, version_id, **kwargs)  # noqa: E501
+
+    def publish_version_api_v2_workspace_templates_template_id_versions_version_id_publish_post_with_http_info(self, template_id, version_id, **kwargs):  # noqa: E501
+        """Publish Version  # noqa: E501
+
+        Publish a version as the active version for a template  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.publish_version_api_v2_workspace_templates_template_id_versions_version_id_publish_post_with_http_info(template_id, version_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str template_id: (required)
+        :param str version_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(object, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'template_id',
+            'version_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 publish_version_api_v2_workspace_templates_template_id_versions_version_id_publish_post" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'template_id' is set
+        if self.api_client.client_side_validation and ('template_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['template_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `template_id` when calling `publish_version_api_v2_workspace_templates_template_id_versions_version_id_publish_post`")  # noqa: E501
+        # verify the required parameter 'version_id' is set
+        if self.api_client.client_side_validation and ('version_id' not in local_var_params or  # noqa: E501
+                                                        local_var_params['version_id'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `version_id` when calling `publish_version_api_v2_workspace_templates_template_id_versions_version_id_publish_post`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'template_id' in local_var_params:
+            path_params['template_id'] = local_var_params['template_id']  # noqa: E501
+        if 'version_id' in local_var_params:
+            path_params['version_id'] = local_var_params['version_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/workspace_templates/{template_id}/versions/{version_id}/publish', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            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
+            _preload_content=local_var_params.get('_preload_content', True),
+            _request_timeout=local_var_params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def push_cloud_overview_dashboard_api_v2_clouds_cloud_id_push_cloud_overview_dashboard_post(self, cloud_id, **kwargs):  # noqa: E501
         """Push Cloud Overview Dashboard  # noqa: E501
 
@@ -32006,17 +33659,138 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def search_support_requests_api_v2_support_requests_search_post(self, support_requests_query, **kwargs):  # noqa: E501
-        """Search Support Requests  # noqa: E501
+    def search_support_requests_api_v2_support_requests_search_post(self, support_requests_query, **kwargs):  # noqa: E501
+        """Search Support Requests  # noqa: E501
+
+        List all decorated support requests matching the search parameters.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.search_support_requests_api_v2_support_requests_search_post(support_requests_query, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param SupportRequestsQuery support_requests_query: (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: DecoratedsupportrequestListResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.search_support_requests_api_v2_support_requests_search_post_with_http_info(support_requests_query, **kwargs)  # noqa: E501
+
+    def search_support_requests_api_v2_support_requests_search_post_with_http_info(self, support_requests_query, **kwargs):  # noqa: E501
+        """Search Support Requests  # noqa: E501
+
+        List all decorated support requests matching the search parameters.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.search_support_requests_api_v2_support_requests_search_post_with_http_info(support_requests_query, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param SupportRequestsQuery support_requests_query: (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(DecoratedsupportrequestListResponse, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'support_requests_query'
+        ]
+        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 search_support_requests_api_v2_support_requests_search_post" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'support_requests_query' is set
+        if self.api_client.client_side_validation and ('support_requests_query' not in local_var_params or  # noqa: E501
+                                                        local_var_params['support_requests_query'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `support_requests_query` when calling `search_support_requests_api_v2_support_requests_search_post`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'support_requests_query' in local_var_params:
+            body_params = local_var_params['support_requests_query']
+        # 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/support_requests/search', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='DecoratedsupportrequestListResponse',  # 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 search_tags_api_v2_tags_get(self, **kwargs):  # noqa: E501
+        """Search Tags  # noqa: E501
 
-        List all decorated support requests matching the search parameters.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.search_support_requests_api_v2_support_requests_search_post(support_requests_query, async_req=True)
+        >>> thread = api.search_tags_api_v2_tags_get(async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param SupportRequestsQuery support_requests_query: (required)
+        :param str substring:
+        :param TagSearchIn search_in:
+        :param ResourceTagResourceType resource_type:
+        :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.
@@ -32024,24 +33798,27 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: DecoratedsupportrequestListResponse
+        :return: TagkeyvalueListResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.search_support_requests_api_v2_support_requests_search_post_with_http_info(support_requests_query, **kwargs)  # noqa: E501
+        return self.search_tags_api_v2_tags_get_with_http_info(**kwargs)  # noqa: E501
 
-    def search_support_requests_api_v2_support_requests_search_post_with_http_info(self, support_requests_query, **kwargs):  # noqa: E501
-        """Search Support Requests  # noqa: E501
+    def search_tags_api_v2_tags_get_with_http_info(self, **kwargs):  # noqa: E501
+        """Search Tags  # noqa: E501
 
-        List all decorated support requests matching the search parameters.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.search_support_requests_api_v2_support_requests_search_post_with_http_info(support_requests_query, async_req=True)
+        >>> thread = api.search_tags_api_v2_tags_get_with_http_info(async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param SupportRequestsQuery support_requests_query: (required)
+        :param str substring:
+        :param TagSearchIn search_in:
+        :param ResourceTagResourceType resource_type:
+        :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
@@ -32051,7 +33828,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(DecoratedsupportrequestListResponse, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(TagkeyvalueListResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -32059,7 +33836,11 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'support_requests_query'
+            'substring',
+            'search_in',
+            'resource_type',
+            'paging_token',
+            'count'
         ]
         all_params.extend(
             [
@@ -32074,20 +33855,30 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method search_support_requests_api_v2_support_requests_search_post" % key
+                    " to method search_tags_api_v2_tags_get" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
-        # verify the required parameter 'support_requests_query' is set
-        if self.api_client.client_side_validation and ('support_requests_query' not in local_var_params or  # noqa: E501
-                                                        local_var_params['support_requests_query'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `support_requests_query` when calling `search_support_requests_api_v2_support_requests_search_post`")  # 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 `search_tags_api_v2_tags_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 `search_tags_api_v2_tags_get`, must be a value greater than or equal to `0`")  # noqa: E501
         collection_formats = {}
 
         path_params = {}
 
         query_params = []
+        if 'substring' in local_var_params and local_var_params['substring'] is not None:  # noqa: E501
+            query_params.append(('substring', local_var_params['substring']))  # noqa: E501
+        if 'search_in' in local_var_params and local_var_params['search_in'] is not None:  # noqa: E501
+            query_params.append(('search_in', local_var_params['search_in']))  # noqa: E501
+        if 'resource_type' in local_var_params and local_var_params['resource_type'] is not None:  # noqa: E501
+            query_params.append(('resource_type', local_var_params['resource_type']))  # 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 = {}
 
@@ -32095,28 +33886,22 @@ class DefaultApi(object):
         local_var_files = {}
 
         body_params = None
-        if 'support_requests_query' in local_var_params:
-            body_params = local_var_params['support_requests_query']
         # 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/support_requests/search', 'POST',
+            '/api/v2/tags/', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='DecoratedsupportrequestListResponse',  # noqa: E501
+            response_type='TagkeyvalueListResponse',  # 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
@@ -36395,14 +38180,248 @@ class DefaultApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/api/v2/session_commands/{session_command_id}/upload_logs', 'POST',
+            '/api/v2/session_commands/{session_command_id}/upload_logs', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='UploadsessioncommandlogslocationsResponse',  # 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 upsert_billing_version_api_v2_organization_billing_billing_versions_put(self, create_billing_version, **kwargs):  # noqa: E501
+        """Upsert Billing Version  # noqa: E501
+
+        Upsert a billing version record for the organization.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.upsert_billing_version_api_v2_organization_billing_billing_versions_put(create_billing_version, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param CreateBillingVersion create_billing_version: (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: object
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.upsert_billing_version_api_v2_organization_billing_billing_versions_put_with_http_info(create_billing_version, **kwargs)  # noqa: E501
+
+    def upsert_billing_version_api_v2_organization_billing_billing_versions_put_with_http_info(self, create_billing_version, **kwargs):  # noqa: E501
+        """Upsert Billing Version  # noqa: E501
+
+        Upsert a billing version record for the organization.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.upsert_billing_version_api_v2_organization_billing_billing_versions_put_with_http_info(create_billing_version, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param CreateBillingVersion create_billing_version: (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(object, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'create_billing_version'
+        ]
+        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 upsert_billing_version_api_v2_organization_billing_billing_versions_put" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'create_billing_version' is set
+        if self.api_client.client_side_validation and ('create_billing_version' not in local_var_params or  # noqa: E501
+                                                        local_var_params['create_billing_version'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `create_billing_version` when calling `upsert_billing_version_api_v2_organization_billing_billing_versions_put`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'create_billing_version' in local_var_params:
+            body_params = local_var_params['create_billing_version']
+        # 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/organization_billing/billing_versions', 'PUT',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            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
+            _preload_content=local_var_params.get('_preload_content', True),
+            _request_timeout=local_var_params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def upsert_resource_tags_api_v2_tags_resource_put(self, upsert_resource_tags_request, **kwargs):  # noqa: E501
+        """Upsert Resource Tags  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.upsert_resource_tags_api_v2_tags_resource_put(upsert_resource_tags_request, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param UpsertResourceTagsRequest upsert_resource_tags_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: object
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.upsert_resource_tags_api_v2_tags_resource_put_with_http_info(upsert_resource_tags_request, **kwargs)  # noqa: E501
+
+    def upsert_resource_tags_api_v2_tags_resource_put_with_http_info(self, upsert_resource_tags_request, **kwargs):  # noqa: E501
+        """Upsert Resource Tags  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.upsert_resource_tags_api_v2_tags_resource_put_with_http_info(upsert_resource_tags_request, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param UpsertResourceTagsRequest upsert_resource_tags_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(object, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'upsert_resource_tags_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 upsert_resource_tags_api_v2_tags_resource_put" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'upsert_resource_tags_request' is set
+        if self.api_client.client_side_validation and ('upsert_resource_tags_request' not in local_var_params or  # noqa: E501
+                                                        local_var_params['upsert_resource_tags_request'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `upsert_resource_tags_request` when calling `upsert_resource_tags_api_v2_tags_resource_put`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'upsert_resource_tags_request' in local_var_params:
+            body_params = local_var_params['upsert_resource_tags_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/tags/resource', 'PUT',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='UploadsessioncommandlogslocationsResponse',  # 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
@@ -36410,17 +38429,16 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def upsert_billing_version_api_v2_organization_billing_billing_versions_put(self, create_billing_version, **kwargs):  # noqa: E501
-        """Upsert Billing Version  # noqa: E501
+    def upsert_support_request_for_user_organization_api_v2_support_requests_support_request_put(self, write_support_request, **kwargs):  # noqa: E501
+        """Upsert Support Request For User Organization  # noqa: E501
 
-        Upsert a billing version record for the organization.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.upsert_billing_version_api_v2_organization_billing_billing_versions_put(create_billing_version, async_req=True)
+        >>> thread = api.upsert_support_request_for_user_organization_api_v2_support_requests_support_request_put(write_support_request, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param CreateBillingVersion create_billing_version: (required)
+        :param WriteSupportRequest write_support_request: (required)
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -36433,19 +38451,18 @@ class DefaultApi(object):
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.upsert_billing_version_api_v2_organization_billing_billing_versions_put_with_http_info(create_billing_version, **kwargs)  # noqa: E501
+        return self.upsert_support_request_for_user_organization_api_v2_support_requests_support_request_put_with_http_info(write_support_request, **kwargs)  # noqa: E501
 
-    def upsert_billing_version_api_v2_organization_billing_billing_versions_put_with_http_info(self, create_billing_version, **kwargs):  # noqa: E501
-        """Upsert Billing Version  # noqa: E501
+    def upsert_support_request_for_user_organization_api_v2_support_requests_support_request_put_with_http_info(self, write_support_request, **kwargs):  # noqa: E501
+        """Upsert Support Request For User Organization  # noqa: E501
 
-        Upsert a billing version record for the organization.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.upsert_billing_version_api_v2_organization_billing_billing_versions_put_with_http_info(create_billing_version, async_req=True)
+        >>> thread = api.upsert_support_request_for_user_organization_api_v2_support_requests_support_request_put_with_http_info(write_support_request, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param CreateBillingVersion create_billing_version: (required)
+        :param WriteSupportRequest write_support_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
@@ -36463,7 +38480,7 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'create_billing_version'
+            'write_support_request'
         ]
         all_params.extend(
             [
@@ -36478,14 +38495,14 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method upsert_billing_version_api_v2_organization_billing_billing_versions_put" % key
+                    " to method upsert_support_request_for_user_organization_api_v2_support_requests_support_request_put" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
-        # verify the required parameter 'create_billing_version' is set
-        if self.api_client.client_side_validation and ('create_billing_version' not in local_var_params or  # noqa: E501
-                                                        local_var_params['create_billing_version'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `create_billing_version` when calling `upsert_billing_version_api_v2_organization_billing_billing_versions_put`")  # noqa: E501
+        # verify the required parameter 'write_support_request' is set
+        if self.api_client.client_side_validation and ('write_support_request' not in local_var_params or  # noqa: E501
+                                                        local_var_params['write_support_request'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `write_support_request` when calling `upsert_support_request_for_user_organization_api_v2_support_requests_support_request_put`")  # noqa: E501
 
         collection_formats = {}
 
@@ -36499,8 +38516,8 @@ class DefaultApi(object):
         local_var_files = {}
 
         body_params = None
-        if 'create_billing_version' in local_var_params:
-            body_params = local_var_params['create_billing_version']
+        if 'write_support_request' in local_var_params:
+            body_params = local_var_params['write_support_request']
         # HTTP header `Accept`
         header_params['Accept'] = self.api_client.select_header_accept(
             ['application/json'])  # noqa: E501
@@ -36513,7 +38530,7 @@ class DefaultApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/api/v2/organization_billing/billing_versions', 'PUT',
+            '/api/v2/support_requests/support_request', 'PUT',
             path_params,
             query_params,
             header_params,
@@ -36528,16 +38545,16 @@ class DefaultApi(object):
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def upsert_support_request_for_user_organization_api_v2_support_requests_support_request_put(self, write_support_request, **kwargs):  # noqa: E501
-        """Upsert Support Request For User Organization  # noqa: E501
+    def use_workos_api_v2_workos_use_workos_get(self, **kwargs):  # noqa: E501
+        """Use Workos  # noqa: E501
 
+        Determine whether to use WorkOS based on the user's IP address. This endpoint evaluates the WorkOS feature flag server-side using the client's IP address for targeting. This allows for IP-based rollouts and geographic targeting of the WorkOS authentication flow. Returns:     UseWorkOSResponse: Contains boolean indicating whether WorkOS should be enabled  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.upsert_support_request_for_user_organization_api_v2_support_requests_support_request_put(write_support_request, async_req=True)
+        >>> thread = api.use_workos_api_v2_workos_use_workos_get(async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param WriteSupportRequest write_support_request: (required)
         :param _preload_content: if False, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Default is True.
@@ -36545,23 +38562,23 @@ class DefaultApi(object):
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
-        :return: object
+        :return: UseworkosresponseResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        return self.upsert_support_request_for_user_organization_api_v2_support_requests_support_request_put_with_http_info(write_support_request, **kwargs)  # noqa: E501
+        return self.use_workos_api_v2_workos_use_workos_get_with_http_info(**kwargs)  # noqa: E501
 
-    def upsert_support_request_for_user_organization_api_v2_support_requests_support_request_put_with_http_info(self, write_support_request, **kwargs):  # noqa: E501
-        """Upsert Support Request For User Organization  # noqa: E501
+    def use_workos_api_v2_workos_use_workos_get_with_http_info(self, **kwargs):  # noqa: E501
+        """Use Workos  # noqa: E501
 
+        Determine whether to use WorkOS based on the user's IP address. This endpoint evaluates the WorkOS feature flag server-side using the client's IP address for targeting. This allows for IP-based rollouts and geographic targeting of the WorkOS authentication flow. Returns:     UseWorkOSResponse: Contains boolean indicating whether WorkOS should be enabled  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.upsert_support_request_for_user_organization_api_v2_support_requests_support_request_put_with_http_info(write_support_request, async_req=True)
+        >>> thread = api.use_workos_api_v2_workos_use_workos_get_with_http_info(async_req=True)
         >>> result = thread.get()
 
         :param async_req bool: execute request asynchronously
-        :param WriteSupportRequest write_support_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
@@ -36571,7 +38588,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(object, status_code(int), headers(HTTPHeaderDict))
+        :return: tuple(UseworkosresponseResponse, status_code(int), headers(HTTPHeaderDict))
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -36579,7 +38596,6 @@ class DefaultApi(object):
         local_var_params = locals()
 
         all_params = [
-            'write_support_request'
         ]
         all_params.extend(
             [
@@ -36594,14 +38610,10 @@ class DefaultApi(object):
             if key not in all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method upsert_support_request_for_user_organization_api_v2_support_requests_support_request_put" % key
+                    " to method use_workos_api_v2_workos_use_workos_get" % key
                 )
             local_var_params[key] = val
         del local_var_params['kwargs']
-        # verify the required parameter 'write_support_request' is set
-        if self.api_client.client_side_validation and ('write_support_request' not in local_var_params or  # noqa: E501
-                                                        local_var_params['write_support_request'] is None):  # noqa: E501
-            raise ApiValueError("Missing the required parameter `write_support_request` when calling `upsert_support_request_for_user_organization_api_v2_support_requests_support_request_put`")  # noqa: E501
 
         collection_formats = {}
 
@@ -36615,28 +38627,22 @@ class DefaultApi(object):
         local_var_files = {}
 
         body_params = None
-        if 'write_support_request' in local_var_params:
-            body_params = local_var_params['write_support_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/support_requests/support_request', 'PUT',
+            '/api/v2/workos/use_workos', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='object',  # noqa: E501
+            response_type='UseworkosresponseResponse',  # 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
@@ -37445,3 +39451,235 @@ class DefaultApi(object):
             _preload_content=local_var_params.get('_preload_content', True),
             _request_timeout=local_var_params.get('_request_timeout'),
             collection_formats=collection_formats)
+
+    def workos_callback_api_v2_workos_callback_get(self, code, **kwargs):  # noqa: E501
+        """Workos Callback  # noqa: E501
+
+        Callback for WorkOS authentication. WorkOS will call this endpoint with a code after the user authenticates with WorkOS.  We use the code to get the user's information from WorkOS and then authenticate the user with Anyscale.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.workos_callback_api_v2_workos_callback_get(code, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str code: (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: object
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.workos_callback_api_v2_workos_callback_get_with_http_info(code, **kwargs)  # noqa: E501
+
+    def workos_callback_api_v2_workos_callback_get_with_http_info(self, code, **kwargs):  # noqa: E501
+        """Workos Callback  # noqa: E501
+
+        Callback for WorkOS authentication. WorkOS will call this endpoint with a code after the user authenticates with WorkOS.  We use the code to get the user's information from WorkOS and then authenticate the user with Anyscale.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.workos_callback_api_v2_workos_callback_get_with_http_info(code, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param str code: (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(object, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'code'
+        ]
+        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 workos_callback_api_v2_workos_callback_get" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'code' is set
+        if self.api_client.client_side_validation and ('code' not in local_var_params or  # noqa: E501
+                                                        local_var_params['code'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `code` when calling `workos_callback_api_v2_workos_callback_get`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+        if 'code' in local_var_params and local_var_params['code'] is not None:  # noqa: E501
+            query_params.append(('code', local_var_params['code']))  # 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/workos/callback', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            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
+            _preload_content=local_var_params.get('_preload_content', True),
+            _request_timeout=local_var_params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def workos_verify_email_code_api_v2_workos_email_verification_verify_post(self, email_verification_request, **kwargs):  # noqa: E501
+        """Workos Verify Email Code  # noqa: E501
+
+        Verify email with a 6-digit code sent by WorkOS.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.workos_verify_email_code_api_v2_workos_email_verification_verify_post(email_verification_request, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param EmailVerificationRequest email_verification_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: EmailverificationresponseResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        return self.workos_verify_email_code_api_v2_workos_email_verification_verify_post_with_http_info(email_verification_request, **kwargs)  # noqa: E501
+
+    def workos_verify_email_code_api_v2_workos_email_verification_verify_post_with_http_info(self, email_verification_request, **kwargs):  # noqa: E501
+        """Workos Verify Email Code  # noqa: E501
+
+        Verify email with a 6-digit code sent by WorkOS.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.workos_verify_email_code_api_v2_workos_email_verification_verify_post_with_http_info(email_verification_request, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool: execute request asynchronously
+        :param EmailVerificationRequest email_verification_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(EmailverificationresponseResponse, status_code(int), headers(HTTPHeaderDict))
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        local_var_params = locals()
+
+        all_params = [
+            'email_verification_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 workos_verify_email_code_api_v2_workos_email_verification_verify_post" % key
+                )
+            local_var_params[key] = val
+        del local_var_params['kwargs']
+        # verify the required parameter 'email_verification_request' is set
+        if self.api_client.client_side_validation and ('email_verification_request' not in local_var_params or  # noqa: E501
+                                                        local_var_params['email_verification_request'] is None):  # noqa: E501
+            raise ApiValueError("Missing the required parameter `email_verification_request` when calling `workos_verify_email_code_api_v2_workos_email_verification_verify_post`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'email_verification_request' in local_var_params:
+            body_params = local_var_params['email_verification_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/workos/email_verification/verify', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='EmailverificationresponseResponse',  # 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)