lightning-sdk 0.1.3__py3-none-any.whl → 0.1.46__py3-none-any.whl

lightning_sdk/lightning_cloud/openapi/api/models_store_api.py

@@ -43,45 +43,1187 @@ class ModelsStoreApi(object):
             api_client = ApiClient()
         self.api_client = api_client
 
+    def models_store_complete_model_upload(self, body: 'object', project_id: 'str', model_id: 'str', version: 'str', **kwargs) -> 'V1CompleteModelUploadResponse':  # noqa: E501
+        """CompleteModelUpload marks the model upload as complete after all files have been uploaded. This marks the model as visible for list, delete, etc. operations  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_complete_model_upload(body, project_id, model_id, version, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param object body: (required)
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :param str version: (required)
+        :return: V1CompleteModelUploadResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.models_store_complete_model_upload_with_http_info(body, project_id, model_id, version, **kwargs)  # noqa: E501
+        else:
+            (data) = self.models_store_complete_model_upload_with_http_info(body, project_id, model_id, version, **kwargs)  # noqa: E501
+            return data
+
+    def models_store_complete_model_upload_with_http_info(self, body: 'object', project_id: 'str', model_id: 'str', version: 'str', **kwargs) -> 'V1CompleteModelUploadResponse':  # noqa: E501
+        """CompleteModelUpload marks the model upload as complete after all files have been uploaded. This marks the model as visible for list, delete, etc. operations  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_complete_model_upload_with_http_info(body, project_id, model_id, version, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param object body: (required)
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :param str version: (required)
+        :return: V1CompleteModelUploadResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body', 'project_id', 'model_id', 'version']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method models_store_complete_model_upload" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if ('body' not in params or
+                params['body'] is None):
+            raise ValueError("Missing the required parameter `body` when calling `models_store_complete_model_upload`")  # noqa: E501
+        # verify the required parameter 'project_id' is set
+        if ('project_id' not in params or
+                params['project_id'] is None):
+            raise ValueError("Missing the required parameter `project_id` when calling `models_store_complete_model_upload`")  # noqa: E501
+        # verify the required parameter 'model_id' is set
+        if ('model_id' not in params or
+                params['model_id'] is None):
+            raise ValueError("Missing the required parameter `model_id` when calling `models_store_complete_model_upload`")  # noqa: E501
+        # verify the required parameter 'version' is set
+        if ('version' not in params or
+                params['version'] is None):
+            raise ValueError("Missing the required parameter `version` when calling `models_store_complete_model_upload`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'project_id' in params:
+            path_params['projectId'] = params['project_id']  # noqa: E501
+        if 'model_id' in params:
+            path_params['modelId'] = params['model_id']  # noqa: E501
+        if 'version' in params:
+            path_params['version'] = params['version']  # noqa: E501
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # 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(
+            '/v1/projects/{projectId}/models/{modelId}/versions/{version}/complete', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='V1CompleteModelUploadResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def models_store_complete_multi_part_upload(self, body: 'UploadIdCompleteBody', project_id: 'str', model_id: 'str', version: 'str', upload_id: 'str', **kwargs) -> 'V1CompleteMultiPartUploadResponse':  # noqa: E501
+        """CompleteMultiPartUpload marks the given file-parts as completed/uploaded. Once all parts of a file are completed, the file will materialize in S3 storage  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_complete_multi_part_upload(body, project_id, model_id, version, upload_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UploadIdCompleteBody body: (required)
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :param str version: (required)
+        :param str upload_id: (required)
+        :return: V1CompleteMultiPartUploadResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.models_store_complete_multi_part_upload_with_http_info(body, project_id, model_id, version, upload_id, **kwargs)  # noqa: E501
+        else:
+            (data) = self.models_store_complete_multi_part_upload_with_http_info(body, project_id, model_id, version, upload_id, **kwargs)  # noqa: E501
+            return data
+
+    def models_store_complete_multi_part_upload_with_http_info(self, body: 'UploadIdCompleteBody', project_id: 'str', model_id: 'str', version: 'str', upload_id: 'str', **kwargs) -> 'V1CompleteMultiPartUploadResponse':  # noqa: E501
+        """CompleteMultiPartUpload marks the given file-parts as completed/uploaded. Once all parts of a file are completed, the file will materialize in S3 storage  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_complete_multi_part_upload_with_http_info(body, project_id, model_id, version, upload_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UploadIdCompleteBody body: (required)
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :param str version: (required)
+        :param str upload_id: (required)
+        :return: V1CompleteMultiPartUploadResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body', 'project_id', 'model_id', 'version', 'upload_id']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method models_store_complete_multi_part_upload" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if ('body' not in params or
+                params['body'] is None):
+            raise ValueError("Missing the required parameter `body` when calling `models_store_complete_multi_part_upload`")  # noqa: E501
+        # verify the required parameter 'project_id' is set
+        if ('project_id' not in params or
+                params['project_id'] is None):
+            raise ValueError("Missing the required parameter `project_id` when calling `models_store_complete_multi_part_upload`")  # noqa: E501
+        # verify the required parameter 'model_id' is set
+        if ('model_id' not in params or
+                params['model_id'] is None):
+            raise ValueError("Missing the required parameter `model_id` when calling `models_store_complete_multi_part_upload`")  # noqa: E501
+        # verify the required parameter 'version' is set
+        if ('version' not in params or
+                params['version'] is None):
+            raise ValueError("Missing the required parameter `version` when calling `models_store_complete_multi_part_upload`")  # noqa: E501
+        # verify the required parameter 'upload_id' is set
+        if ('upload_id' not in params or
+                params['upload_id'] is None):
+            raise ValueError("Missing the required parameter `upload_id` when calling `models_store_complete_multi_part_upload`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'project_id' in params:
+            path_params['projectId'] = params['project_id']  # noqa: E501
+        if 'model_id' in params:
+            path_params['modelId'] = params['model_id']  # noqa: E501
+        if 'version' in params:
+            path_params['version'] = params['version']  # noqa: E501
+        if 'upload_id' in params:
+            path_params['uploadId'] = params['upload_id']  # noqa: E501
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # 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(
+            '/v1/projects/{projectId}/models/{modelId}/versions/{version}/uploads/{uploadId}/complete', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='V1CompleteMultiPartUploadResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def models_store_create_model(self, body: 'ProjectIdModelsBody', project_id: 'str', **kwargs) -> 'V1ModelVersionArchive':  # noqa: E501
+        """CreateModel creates a new version of a model and marks the upload as incomplete. Files are expected to be uploaded using the multi-part upload APIs below, followed by a completion request after which the model will be fully visible (can list, delete etc.)  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_create_model(body, project_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ProjectIdModelsBody body: (required)
+        :param str project_id: (required)
+        :return: V1ModelVersionArchive
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.models_store_create_model_with_http_info(body, project_id, **kwargs)  # noqa: E501
+        else:
+            (data) = self.models_store_create_model_with_http_info(body, project_id, **kwargs)  # noqa: E501
+            return data
+
+    def models_store_create_model_with_http_info(self, body: 'ProjectIdModelsBody', project_id: 'str', **kwargs) -> 'V1ModelVersionArchive':  # noqa: E501
+        """CreateModel creates a new version of a model and marks the upload as incomplete. Files are expected to be uploaded using the multi-part upload APIs below, followed by a completion request after which the model will be fully visible (can list, delete etc.)  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_create_model_with_http_info(body, project_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ProjectIdModelsBody body: (required)
+        :param str project_id: (required)
+        :return: V1ModelVersionArchive
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body', 'project_id']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method models_store_create_model" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if ('body' not in params or
+                params['body'] is None):
+            raise ValueError("Missing the required parameter `body` when calling `models_store_create_model`")  # noqa: E501
+        # verify the required parameter 'project_id' is set
+        if ('project_id' not in params or
+                params['project_id'] is None):
+            raise ValueError("Missing the required parameter `project_id` when calling `models_store_create_model`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'project_id' in params:
+            path_params['projectId'] = params['project_id']  # noqa: E501
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # 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(
+            '/v1/projects/{projectId}/models', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='V1ModelVersionArchive',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def models_store_create_model_version(self, body: 'ModelIdVersionsBody', project_id: 'str', model_id: 'str', **kwargs) -> 'V1ModelVersionArchive':  # noqa: E501
+        """models_store_create_model_version  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_create_model_version(body, project_id, model_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModelIdVersionsBody body: (required)
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :return: V1ModelVersionArchive
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.models_store_create_model_version_with_http_info(body, project_id, model_id, **kwargs)  # noqa: E501
+        else:
+            (data) = self.models_store_create_model_version_with_http_info(body, project_id, model_id, **kwargs)  # noqa: E501
+            return data
+
+    def models_store_create_model_version_with_http_info(self, body: 'ModelIdVersionsBody', project_id: 'str', model_id: 'str', **kwargs) -> 'V1ModelVersionArchive':  # noqa: E501
+        """models_store_create_model_version  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_create_model_version_with_http_info(body, project_id, model_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModelIdVersionsBody body: (required)
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :return: V1ModelVersionArchive
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body', 'project_id', 'model_id']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method models_store_create_model_version" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if ('body' not in params or
+                params['body'] is None):
+            raise ValueError("Missing the required parameter `body` when calling `models_store_create_model_version`")  # noqa: E501
+        # verify the required parameter 'project_id' is set
+        if ('project_id' not in params or
+                params['project_id'] is None):
+            raise ValueError("Missing the required parameter `project_id` when calling `models_store_create_model_version`")  # noqa: E501
+        # verify the required parameter 'model_id' is set
+        if ('model_id' not in params or
+                params['model_id'] is None):
+            raise ValueError("Missing the required parameter `model_id` when calling `models_store_create_model_version`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'project_id' in params:
+            path_params['projectId'] = params['project_id']  # noqa: E501
+        if 'model_id' in params:
+            path_params['modelId'] = params['model_id']  # noqa: E501
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # 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(
+            '/v1/projects/{projectId}/models/{modelId}/versions', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='V1ModelVersionArchive',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def models_store_create_multi_part_upload(self, body: 'VersionUploadsBody', project_id: 'str', model_id: 'str', version: 'str', **kwargs) -> 'V1CreateMultiPartUploadResponse':  # noqa: E501
+        """CreateMultiPartUpload initiates the multi-part upload of a file. Multiple requests can be sent to upload different files.  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_create_multi_part_upload(body, project_id, model_id, version, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param VersionUploadsBody body: (required)
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :param str version: (required)
+        :return: V1CreateMultiPartUploadResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.models_store_create_multi_part_upload_with_http_info(body, project_id, model_id, version, **kwargs)  # noqa: E501
+        else:
+            (data) = self.models_store_create_multi_part_upload_with_http_info(body, project_id, model_id, version, **kwargs)  # noqa: E501
+            return data
+
+    def models_store_create_multi_part_upload_with_http_info(self, body: 'VersionUploadsBody', project_id: 'str', model_id: 'str', version: 'str', **kwargs) -> 'V1CreateMultiPartUploadResponse':  # noqa: E501
+        """CreateMultiPartUpload initiates the multi-part upload of a file. Multiple requests can be sent to upload different files.  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_create_multi_part_upload_with_http_info(body, project_id, model_id, version, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param VersionUploadsBody body: (required)
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :param str version: (required)
+        :return: V1CreateMultiPartUploadResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body', 'project_id', 'model_id', 'version']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method models_store_create_multi_part_upload" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if ('body' not in params or
+                params['body'] is None):
+            raise ValueError("Missing the required parameter `body` when calling `models_store_create_multi_part_upload`")  # noqa: E501
+        # verify the required parameter 'project_id' is set
+        if ('project_id' not in params or
+                params['project_id'] is None):
+            raise ValueError("Missing the required parameter `project_id` when calling `models_store_create_multi_part_upload`")  # noqa: E501
+        # verify the required parameter 'model_id' is set
+        if ('model_id' not in params or
+                params['model_id'] is None):
+            raise ValueError("Missing the required parameter `model_id` when calling `models_store_create_multi_part_upload`")  # noqa: E501
+        # verify the required parameter 'version' is set
+        if ('version' not in params or
+                params['version'] is None):
+            raise ValueError("Missing the required parameter `version` when calling `models_store_create_multi_part_upload`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'project_id' in params:
+            path_params['projectId'] = params['project_id']  # noqa: E501
+        if 'model_id' in params:
+            path_params['modelId'] = params['model_id']  # noqa: E501
+        if 'version' in params:
+            path_params['version'] = params['version']  # noqa: E501
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # 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(
+            '/v1/projects/{projectId}/models/{modelId}/versions/{version}/uploads', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='V1CreateMultiPartUploadResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
     def models_store_delete_model(self, project_id: 'str', model_id: 'str', **kwargs) -> 'V1DeleteModelResponse':  # noqa: E501
         """DeleteModel is used to delete the model and all uploaded archives  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.models_store_delete_model(project_id, model_id, async_req=True)
+        >>> thread = api.models_store_delete_model(project_id, model_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :return: V1DeleteModelResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.models_store_delete_model_with_http_info(project_id, model_id, **kwargs)  # noqa: E501
+        else:
+            (data) = self.models_store_delete_model_with_http_info(project_id, model_id, **kwargs)  # noqa: E501
+            return data
+
+    def models_store_delete_model_with_http_info(self, project_id: 'str', model_id: 'str', **kwargs) -> 'V1DeleteModelResponse':  # noqa: E501
+        """DeleteModel is used to delete the model and all uploaded archives  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_delete_model_with_http_info(project_id, model_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :return: V1DeleteModelResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['project_id', 'model_id']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method models_store_delete_model" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'project_id' is set
+        if ('project_id' not in params or
+                params['project_id'] is None):
+            raise ValueError("Missing the required parameter `project_id` when calling `models_store_delete_model`")  # noqa: E501
+        # verify the required parameter 'model_id' is set
+        if ('model_id' not in params or
+                params['model_id'] is None):
+            raise ValueError("Missing the required parameter `model_id` when calling `models_store_delete_model`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'project_id' in params:
+            path_params['projectId'] = params['project_id']  # noqa: E501
+        if 'model_id' in params:
+            path_params['modelId'] = params['model_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(
+            '/v1/projects/{projectId}/models/{modelId}', 'DELETE',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='V1DeleteModelResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def models_store_delete_model_version(self, project_id: 'str', model_id: 'str', version: 'str', **kwargs) -> 'V1DeleteModelVersionResponse':  # noqa: E501
+        """DeleteModelVersion is used to delete a specific model version  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_delete_model_version(project_id, model_id, version, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :param str version: (required)
+        :return: V1DeleteModelVersionResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.models_store_delete_model_version_with_http_info(project_id, model_id, version, **kwargs)  # noqa: E501
+        else:
+            (data) = self.models_store_delete_model_version_with_http_info(project_id, model_id, version, **kwargs)  # noqa: E501
+            return data
+
+    def models_store_delete_model_version_with_http_info(self, project_id: 'str', model_id: 'str', version: 'str', **kwargs) -> 'V1DeleteModelVersionResponse':  # noqa: E501
+        """DeleteModelVersion is used to delete a specific model version  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_delete_model_version_with_http_info(project_id, model_id, version, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :param str version: (required)
+        :return: V1DeleteModelVersionResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['project_id', 'model_id', 'version']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method models_store_delete_model_version" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'project_id' is set
+        if ('project_id' not in params or
+                params['project_id'] is None):
+            raise ValueError("Missing the required parameter `project_id` when calling `models_store_delete_model_version`")  # noqa: E501
+        # verify the required parameter 'model_id' is set
+        if ('model_id' not in params or
+                params['model_id'] is None):
+            raise ValueError("Missing the required parameter `model_id` when calling `models_store_delete_model_version`")  # noqa: E501
+        # verify the required parameter 'version' is set
+        if ('version' not in params or
+                params['version'] is None):
+            raise ValueError("Missing the required parameter `version` when calling `models_store_delete_model_version`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'project_id' in params:
+            path_params['projectId'] = params['project_id']  # noqa: E501
+        if 'model_id' in params:
+            path_params['modelId'] = params['model_id']  # noqa: E501
+        if 'version' in params:
+            path_params['version'] = params['version']  # 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(
+            '/v1/projects/{projectId}/models/{modelId}/versions/{version}', 'DELETE',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='V1DeleteModelVersionResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def models_store_get_model(self, project_id: 'str', model_id: 'str', **kwargs) -> 'V1Model':  # noqa: E501
+        """GetModel used to get specific model 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.models_store_get_model(project_id, model_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :return: V1Model
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.models_store_get_model_with_http_info(project_id, model_id, **kwargs)  # noqa: E501
+        else:
+            (data) = self.models_store_get_model_with_http_info(project_id, model_id, **kwargs)  # noqa: E501
+            return data
+
+    def models_store_get_model_with_http_info(self, project_id: 'str', model_id: 'str', **kwargs) -> 'V1Model':  # noqa: E501
+        """GetModel used to get specific model 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.models_store_get_model_with_http_info(project_id, model_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :return: V1Model
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['project_id', 'model_id']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method models_store_get_model" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'project_id' is set
+        if ('project_id' not in params or
+                params['project_id'] is None):
+            raise ValueError("Missing the required parameter `project_id` when calling `models_store_get_model`")  # noqa: E501
+        # verify the required parameter 'model_id' is set
+        if ('model_id' not in params or
+                params['model_id'] is None):
+            raise ValueError("Missing the required parameter `model_id` when calling `models_store_get_model`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'project_id' in params:
+            path_params['projectId'] = params['project_id']  # noqa: E501
+        if 'model_id' in params:
+            path_params['modelId'] = params['model_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(
+            '/v1/projects/{projectId}/models/{modelId}', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='V1Model',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def models_store_get_model_by_name(self, project_owner_name: 'str', project_name: 'str', model_name: 'str', **kwargs) -> 'V1Model':  # noqa: E501
+        """models_store_get_model_by_name  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_get_model_by_name(project_owner_name, project_name, model_name, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param str project_owner_name: (required)
+        :param str project_name: (required)
+        :param str model_name: (required)
+        :return: V1Model
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.models_store_get_model_by_name_with_http_info(project_owner_name, project_name, model_name, **kwargs)  # noqa: E501
+        else:
+            (data) = self.models_store_get_model_by_name_with_http_info(project_owner_name, project_name, model_name, **kwargs)  # noqa: E501
+            return data
+
+    def models_store_get_model_by_name_with_http_info(self, project_owner_name: 'str', project_name: 'str', model_name: 'str', **kwargs) -> 'V1Model':  # noqa: E501
+        """models_store_get_model_by_name  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_get_model_by_name_with_http_info(project_owner_name, project_name, model_name, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param str project_owner_name: (required)
+        :param str project_name: (required)
+        :param str model_name: (required)
+        :return: V1Model
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['project_owner_name', 'project_name', 'model_name']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method models_store_get_model_by_name" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'project_owner_name' is set
+        if ('project_owner_name' not in params or
+                params['project_owner_name'] is None):
+            raise ValueError("Missing the required parameter `project_owner_name` when calling `models_store_get_model_by_name`")  # noqa: E501
+        # verify the required parameter 'project_name' is set
+        if ('project_name' not in params or
+                params['project_name'] is None):
+            raise ValueError("Missing the required parameter `project_name` when calling `models_store_get_model_by_name`")  # noqa: E501
+        # verify the required parameter 'model_name' is set
+        if ('model_name' not in params or
+                params['model_name'] is None):
+            raise ValueError("Missing the required parameter `model_name` when calling `models_store_get_model_by_name`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'project_owner_name' in params:
+            path_params['projectOwnerName'] = params['project_owner_name']  # noqa: E501
+        if 'project_name' in params:
+            path_params['projectName'] = params['project_name']  # noqa: E501
+        if 'model_name' in params:
+            path_params['modelName'] = params['model_name']  # 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(
+            '/v1/projects/{projectOwnerName}/{projectName}/models/{modelName}', 'GET',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='V1Model',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def models_store_get_model_file_upload_urls(self, body: 'UploadIdPartsBody', project_id: 'str', model_id: 'str', version: 'str', upload_id: 'str', **kwargs) -> 'V1GetModelFileUploadUrlsResponse':  # noqa: E501
+        """GetModelFileUploadUrls requests pre-signed URLs for a given number of file parts.  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_get_model_file_upload_urls(body, project_id, model_id, version, upload_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UploadIdPartsBody body: (required)
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :param str version: (required)
+        :param str upload_id: (required)
+        :return: V1GetModelFileUploadUrlsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.models_store_get_model_file_upload_urls_with_http_info(body, project_id, model_id, version, upload_id, **kwargs)  # noqa: E501
+        else:
+            (data) = self.models_store_get_model_file_upload_urls_with_http_info(body, project_id, model_id, version, upload_id, **kwargs)  # noqa: E501
+            return data
+
+    def models_store_get_model_file_upload_urls_with_http_info(self, body: 'UploadIdPartsBody', project_id: 'str', model_id: 'str', version: 'str', upload_id: 'str', **kwargs) -> 'V1GetModelFileUploadUrlsResponse':  # noqa: E501
+        """GetModelFileUploadUrls requests pre-signed URLs for a given number of file parts.  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_get_model_file_upload_urls_with_http_info(body, project_id, model_id, version, upload_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param UploadIdPartsBody body: (required)
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :param str version: (required)
+        :param str upload_id: (required)
+        :return: V1GetModelFileUploadUrlsResponse
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body', 'project_id', 'model_id', 'version', 'upload_id']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method models_store_get_model_file_upload_urls" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if ('body' not in params or
+                params['body'] is None):
+            raise ValueError("Missing the required parameter `body` when calling `models_store_get_model_file_upload_urls`")  # noqa: E501
+        # verify the required parameter 'project_id' is set
+        if ('project_id' not in params or
+                params['project_id'] is None):
+            raise ValueError("Missing the required parameter `project_id` when calling `models_store_get_model_file_upload_urls`")  # noqa: E501
+        # verify the required parameter 'model_id' is set
+        if ('model_id' not in params or
+                params['model_id'] is None):
+            raise ValueError("Missing the required parameter `model_id` when calling `models_store_get_model_file_upload_urls`")  # noqa: E501
+        # verify the required parameter 'version' is set
+        if ('version' not in params or
+                params['version'] is None):
+            raise ValueError("Missing the required parameter `version` when calling `models_store_get_model_file_upload_urls`")  # noqa: E501
+        # verify the required parameter 'upload_id' is set
+        if ('upload_id' not in params or
+                params['upload_id'] is None):
+            raise ValueError("Missing the required parameter `upload_id` when calling `models_store_get_model_file_upload_urls`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'project_id' in params:
+            path_params['projectId'] = params['project_id']  # noqa: E501
+        if 'model_id' in params:
+            path_params['modelId'] = params['model_id']  # noqa: E501
+        if 'version' in params:
+            path_params['version'] = params['version']  # noqa: E501
+        if 'upload_id' in params:
+            path_params['uploadId'] = params['upload_id']  # noqa: E501
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # 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(
+            '/v1/projects/{projectId}/models/{modelId}/versions/{version}/uploads/{uploadId}/parts', 'POST',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='V1GetModelFileUploadUrlsResponse',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def models_store_get_model_file_url(self, project_id: 'str', model_id: 'str', version: 'str', **kwargs) -> 'V1GetModelFileUrlResponse':  # noqa: E501
+        """GetModelFileUrl responds with a pre-signed url for a given file  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_get_model_file_url(project_id, model_id, version, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
         :param str project_id: (required)
         :param str model_id: (required)
-        :return: V1DeleteModelResponse
+        :param str version: (required)
+        :param str filepath:
+        :return: V1GetModelFileUrlResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.models_store_delete_model_with_http_info(project_id, model_id, **kwargs)  # noqa: E501
+            return self.models_store_get_model_file_url_with_http_info(project_id, model_id, version, **kwargs)  # noqa: E501
         else:
-            (data) = self.models_store_delete_model_with_http_info(project_id, model_id, **kwargs)  # noqa: E501
+            (data) = self.models_store_get_model_file_url_with_http_info(project_id, model_id, version, **kwargs)  # noqa: E501
             return data
 
-    def models_store_delete_model_with_http_info(self, project_id: 'str', model_id: 'str', **kwargs) -> 'V1DeleteModelResponse':  # noqa: E501
-        """DeleteModel is used to delete the model and all uploaded archives  # noqa: E501
+    def models_store_get_model_file_url_with_http_info(self, project_id: 'str', model_id: 'str', version: 'str', **kwargs) -> 'V1GetModelFileUrlResponse':  # noqa: E501
+        """GetModelFileUrl responds with a pre-signed url for a given file  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.models_store_delete_model_with_http_info(project_id, model_id, async_req=True)
+        >>> thread = api.models_store_get_model_file_url_with_http_info(project_id, model_id, version, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
         :param str project_id: (required)
         :param str model_id: (required)
-        :return: V1DeleteModelResponse
+        :param str version: (required)
+        :param str filepath:
+        :return: V1GetModelFileUrlResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
 
-        all_params = ['project_id', 'model_id']  # noqa: E501
+        all_params = ['project_id', 'model_id', 'version', 'filepath']  # noqa: E501
         all_params.append('async_req')
         all_params.append('_return_http_data_only')
         all_params.append('_preload_content')
@@ -92,18 +1234,22 @@ class ModelsStoreApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method models_store_delete_model" % key
+                    " to method models_store_get_model_file_url" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'project_id' is set
         if ('project_id' not in params or
                 params['project_id'] is None):
-            raise ValueError("Missing the required parameter `project_id` when calling `models_store_delete_model`")  # noqa: E501
+            raise ValueError("Missing the required parameter `project_id` when calling `models_store_get_model_file_url`")  # noqa: E501
         # verify the required parameter 'model_id' is set
         if ('model_id' not in params or
                 params['model_id'] is None):
-            raise ValueError("Missing the required parameter `model_id` when calling `models_store_delete_model`")  # noqa: E501
+            raise ValueError("Missing the required parameter `model_id` when calling `models_store_get_model_file_url`")  # noqa: E501
+        # verify the required parameter 'version' is set
+        if ('version' not in params or
+                params['version'] is None):
+            raise ValueError("Missing the required parameter `version` when calling `models_store_get_model_file_url`")  # noqa: E501
 
         collection_formats = {}
 
@@ -112,8 +1258,12 @@ class ModelsStoreApi(object):
             path_params['projectId'] = params['project_id']  # noqa: E501
         if 'model_id' in params:
             path_params['modelId'] = params['model_id']  # noqa: E501
+        if 'version' in params:
+            path_params['version'] = params['version']  # noqa: E501
 
         query_params = []
+        if 'filepath' in params:
+            query_params.append(('filepath', params['filepath']))  # noqa: E501
 
         header_params = {}
 
@@ -129,14 +1279,14 @@ class ModelsStoreApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/v1/projects/{projectId}/models/{modelId}', 'DELETE',
+            '/v1/projects/{projectId}/models/{modelId}/versions/{version}/file', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='V1DeleteModelResponse',  # noqa: E501
+            response_type='V1GetModelFileUrlResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -144,47 +1294,53 @@ class ModelsStoreApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def models_store_delete_model_version(self, project_id: 'str', model_id: 'str', version: 'str', **kwargs) -> 'V1DeleteModelVersionResponse':  # noqa: E501
-        """DeleteModelVersion is used to delete a specific model version  # noqa: E501
+    def models_store_get_model_files(self, **kwargs) -> 'V1GetModelFilesResponse':  # noqa: E501
+        """GetModelFiles returns a list of file paths (relative to model folder) to download, and for each you can request a pre-signed url for download  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.models_store_delete_model_version(project_id, model_id, version, async_req=True)
+        >>> thread = api.models_store_get_model_files(async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param str project_id: (required)
-        :param str model_id: (required)
-        :param str version: (required)
-        :return: V1DeleteModelVersionResponse
+        :param str name:
+        :param str version:
+        :param str project_id:
+        :param str project_name:
+        :param str project_owner_name:
+        :param str id:
+        :return: V1GetModelFilesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.models_store_delete_model_version_with_http_info(project_id, model_id, version, **kwargs)  # noqa: E501
+            return self.models_store_get_model_files_with_http_info(**kwargs)  # noqa: E501
         else:
-            (data) = self.models_store_delete_model_version_with_http_info(project_id, model_id, version, **kwargs)  # noqa: E501
+            (data) = self.models_store_get_model_files_with_http_info(**kwargs)  # noqa: E501
             return data
 
-    def models_store_delete_model_version_with_http_info(self, project_id: 'str', model_id: 'str', version: 'str', **kwargs) -> 'V1DeleteModelVersionResponse':  # noqa: E501
-        """DeleteModelVersion is used to delete a specific model version  # noqa: E501
+    def models_store_get_model_files_with_http_info(self, **kwargs) -> 'V1GetModelFilesResponse':  # noqa: E501
+        """GetModelFiles returns a list of file paths (relative to model folder) to download, and for each you can request a pre-signed url for download  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.models_store_delete_model_version_with_http_info(project_id, model_id, version, async_req=True)
+        >>> thread = api.models_store_get_model_files_with_http_info(async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param str project_id: (required)
-        :param str model_id: (required)
-        :param str version: (required)
-        :return: V1DeleteModelVersionResponse
+        :param str name:
+        :param str version:
+        :param str project_id:
+        :param str project_name:
+        :param str project_owner_name:
+        :param str id:
+        :return: V1GetModelFilesResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
 
-        all_params = ['project_id', 'model_id', 'version']  # noqa: E501
+        all_params = ['name', 'version', 'project_id', 'project_name', 'project_owner_name', 'id']  # noqa: E501
         all_params.append('async_req')
         all_params.append('_return_http_data_only')
         all_params.append('_preload_content')
@@ -195,34 +1351,28 @@ class ModelsStoreApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method models_store_delete_model_version" % key
+                    " to method models_store_get_model_files" % key
                 )
             params[key] = val
         del params['kwargs']
-        # verify the required parameter 'project_id' is set
-        if ('project_id' not in params or
-                params['project_id'] is None):
-            raise ValueError("Missing the required parameter `project_id` when calling `models_store_delete_model_version`")  # noqa: E501
-        # verify the required parameter 'model_id' is set
-        if ('model_id' not in params or
-                params['model_id'] is None):
-            raise ValueError("Missing the required parameter `model_id` when calling `models_store_delete_model_version`")  # noqa: E501
-        # verify the required parameter 'version' is set
-        if ('version' not in params or
-                params['version'] is None):
-            raise ValueError("Missing the required parameter `version` when calling `models_store_delete_model_version`")  # noqa: E501
 
         collection_formats = {}
 
         path_params = {}
-        if 'project_id' in params:
-            path_params['projectId'] = params['project_id']  # noqa: E501
-        if 'model_id' in params:
-            path_params['modelId'] = params['model_id']  # noqa: E501
-        if 'version' in params:
-            path_params['version'] = params['version']  # noqa: E501
 
         query_params = []
+        if 'name' in params:
+            query_params.append(('name', params['name']))  # noqa: E501
+        if 'version' in params:
+            query_params.append(('version', params['version']))  # noqa: E501
+        if 'project_id' in params:
+            query_params.append(('projectId', params['project_id']))  # noqa: E501
+        if 'project_name' in params:
+            query_params.append(('projectName', params['project_name']))  # noqa: E501
+        if 'project_owner_name' in params:
+            query_params.append(('projectOwnerName', params['project_owner_name']))  # noqa: E501
+        if 'id' in params:
+            query_params.append(('id', params['id']))  # noqa: E501
 
         header_params = {}
 
@@ -238,14 +1388,14 @@ class ModelsStoreApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/v1/projects/{projectId}/models/{modelId}/versions/{version}', 'DELETE',
+            '/v1/models', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='V1DeleteModelVersionResponse',  # noqa: E501
+            response_type='V1GetModelFilesResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -253,45 +1403,51 @@ class ModelsStoreApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def models_store_download_model(self, **kwargs) -> 'V1DownloadModelResponse':  # noqa: E501
-        """DownloadModel is a public facing API used by the Python library to get a presigned URL to download the model. Name is a required query parameter  # noqa: E501
+    def models_store_get_model_files_url(self, project_id: 'str', model_id: 'str', version: 'str', **kwargs) -> 'V1GetModelFilesUrlResponse':  # noqa: E501
+        """GetModelFileUrl responds with a pre-signed url for a given file  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.models_store_download_model(async_req=True)
+        >>> thread = api.models_store_get_model_files_url(project_id, model_id, version, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param str name:
-        :param str version:
-        :return: V1DownloadModelResponse
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :param str version: (required)
+        :param str page_size:
+        :param str offset:
+        :return: V1GetModelFilesUrlResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.models_store_download_model_with_http_info(**kwargs)  # noqa: E501
+            return self.models_store_get_model_files_url_with_http_info(project_id, model_id, version, **kwargs)  # noqa: E501
         else:
-            (data) = self.models_store_download_model_with_http_info(**kwargs)  # noqa: E501
+            (data) = self.models_store_get_model_files_url_with_http_info(project_id, model_id, version, **kwargs)  # noqa: E501
             return data
 
-    def models_store_download_model_with_http_info(self, **kwargs) -> 'V1DownloadModelResponse':  # noqa: E501
-        """DownloadModel is a public facing API used by the Python library to get a presigned URL to download the model. Name is a required query parameter  # noqa: E501
+    def models_store_get_model_files_url_with_http_info(self, project_id: 'str', model_id: 'str', version: 'str', **kwargs) -> 'V1GetModelFilesUrlResponse':  # noqa: E501
+        """GetModelFileUrl responds with a pre-signed url for a given file  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.models_store_download_model_with_http_info(async_req=True)
+        >>> thread = api.models_store_get_model_files_url_with_http_info(project_id, model_id, version, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param str name:
-        :param str version:
-        :return: V1DownloadModelResponse
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :param str version: (required)
+        :param str page_size:
+        :param str offset:
+        :return: V1GetModelFilesUrlResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
 
-        all_params = ['name', 'version']  # noqa: E501
+        all_params = ['project_id', 'model_id', 'version', 'page_size', 'offset']  # noqa: E501
         all_params.append('async_req')
         all_params.append('_return_http_data_only')
         all_params.append('_preload_content')
@@ -302,20 +1458,38 @@ class ModelsStoreApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method models_store_download_model" % key
+                    " to method models_store_get_model_files_url" % key
                 )
             params[key] = val
         del params['kwargs']
+        # verify the required parameter 'project_id' is set
+        if ('project_id' not in params or
+                params['project_id'] is None):
+            raise ValueError("Missing the required parameter `project_id` when calling `models_store_get_model_files_url`")  # noqa: E501
+        # verify the required parameter 'model_id' is set
+        if ('model_id' not in params or
+                params['model_id'] is None):
+            raise ValueError("Missing the required parameter `model_id` when calling `models_store_get_model_files_url`")  # noqa: E501
+        # verify the required parameter 'version' is set
+        if ('version' not in params or
+                params['version'] is None):
+            raise ValueError("Missing the required parameter `version` when calling `models_store_get_model_files_url`")  # noqa: E501
 
         collection_formats = {}
 
         path_params = {}
+        if 'project_id' in params:
+            path_params['projectId'] = params['project_id']  # noqa: E501
+        if 'model_id' in params:
+            path_params['modelId'] = params['model_id']  # noqa: E501
+        if 'version' in params:
+            path_params['version'] = params['version']  # noqa: E501
 
         query_params = []
-        if 'name' in params:
-            query_params.append(('name', params['name']))  # noqa: E501
-        if 'version' in params:
-            query_params.append(('version', params['version']))  # noqa: E501
+        if 'page_size' in params:
+            query_params.append(('pageSize', params['page_size']))  # noqa: E501
+        if 'offset' in params:
+            query_params.append(('offset', params['offset']))  # noqa: E501
 
         header_params = {}
 
@@ -331,14 +1505,14 @@ class ModelsStoreApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/v1/models', 'GET',
+            '/v1/projects/{projectId}/models/{modelId}/versions/{version}/files', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='V1DownloadModelResponse',  # noqa: E501
+            response_type='V1GetModelFilesUrlResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -346,45 +1520,47 @@ class ModelsStoreApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def models_store_get_model(self, project_id: 'str', model_id: 'str', **kwargs) -> 'V1Model':  # noqa: E501
-        """GetModel used to get specific model details  # noqa: E501
+    def models_store_get_model_version(self, project_id: 'str', model_id: 'str', version: 'str', **kwargs) -> 'V1ModelVersionArchive':  # noqa: E501
+        """GetModelVersion used to get specific model version 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.models_store_get_model(project_id, model_id, async_req=True)
+        >>> thread = api.models_store_get_model_version(project_id, model_id, version, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
         :param str project_id: (required)
         :param str model_id: (required)
-        :return: V1Model
+        :param str version: (required)
+        :return: V1ModelVersionArchive
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.models_store_get_model_with_http_info(project_id, model_id, **kwargs)  # noqa: E501
+            return self.models_store_get_model_version_with_http_info(project_id, model_id, version, **kwargs)  # noqa: E501
         else:
-            (data) = self.models_store_get_model_with_http_info(project_id, model_id, **kwargs)  # noqa: E501
+            (data) = self.models_store_get_model_version_with_http_info(project_id, model_id, version, **kwargs)  # noqa: E501
             return data
 
-    def models_store_get_model_with_http_info(self, project_id: 'str', model_id: 'str', **kwargs) -> 'V1Model':  # noqa: E501
-        """GetModel used to get specific model details  # noqa: E501
+    def models_store_get_model_version_with_http_info(self, project_id: 'str', model_id: 'str', version: 'str', **kwargs) -> 'V1ModelVersionArchive':  # noqa: E501
+        """GetModelVersion used to get specific model version 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.models_store_get_model_with_http_info(project_id, model_id, async_req=True)
+        >>> thread = api.models_store_get_model_version_with_http_info(project_id, model_id, version, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
         :param str project_id: (required)
         :param str model_id: (required)
-        :return: V1Model
+        :param str version: (required)
+        :return: V1ModelVersionArchive
                  If the method is called asynchronously,
                  returns the request thread.
         """
 
-        all_params = ['project_id', 'model_id']  # noqa: E501
+        all_params = ['project_id', 'model_id', 'version']  # noqa: E501
         all_params.append('async_req')
         all_params.append('_return_http_data_only')
         all_params.append('_preload_content')
@@ -395,18 +1571,22 @@ class ModelsStoreApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method models_store_get_model" % key
+                    " to method models_store_get_model_version" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'project_id' is set
         if ('project_id' not in params or
                 params['project_id'] is None):
-            raise ValueError("Missing the required parameter `project_id` when calling `models_store_get_model`")  # noqa: E501
+            raise ValueError("Missing the required parameter `project_id` when calling `models_store_get_model_version`")  # noqa: E501
         # verify the required parameter 'model_id' is set
         if ('model_id' not in params or
                 params['model_id'] is None):
-            raise ValueError("Missing the required parameter `model_id` when calling `models_store_get_model`")  # noqa: E501
+            raise ValueError("Missing the required parameter `model_id` when calling `models_store_get_model_version`")  # noqa: E501
+        # verify the required parameter 'version' is set
+        if ('version' not in params or
+                params['version'] is None):
+            raise ValueError("Missing the required parameter `version` when calling `models_store_get_model_version`")  # noqa: E501
 
         collection_formats = {}
 
@@ -415,6 +1595,8 @@ class ModelsStoreApi(object):
             path_params['projectId'] = params['project_id']  # noqa: E501
         if 'model_id' in params:
             path_params['modelId'] = params['model_id']  # noqa: E501
+        if 'version' in params:
+            path_params['version'] = params['version']  # noqa: E501
 
         query_params = []
 
@@ -432,14 +1614,14 @@ class ModelsStoreApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/v1/projects/{projectId}/models/{modelId}', 'GET',
+            '/v1/projects/{projectId}/models/{modelId}/versions/{version}', 'GET',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='V1Model',  # noqa: E501
+            response_type='V1ModelVersionArchive',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
@@ -558,6 +1740,7 @@ class ModelsStoreApi(object):
 
         :param async_req bool
         :param str project_id: (required)
+        :param str name:
         :return: V1ListModelsResponse
                  If the method is called asynchronously,
                  returns the request thread.
@@ -579,12 +1762,13 @@ class ModelsStoreApi(object):
 
         :param async_req bool
         :param str project_id: (required)
+        :param str name:
         :return: V1ListModelsResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
 
-        all_params = ['project_id']  # noqa: E501
+        all_params = ['project_id', 'name']  # noqa: E501
         all_params.append('async_req')
         all_params.append('_return_http_data_only')
         all_params.append('_preload_content')
@@ -611,6 +1795,8 @@ class ModelsStoreApi(object):
             path_params['projectId'] = params['project_id']  # noqa: E501
 
         query_params = []
+        if 'name' in params:
+            query_params.append(('name', params['name']))  # noqa: E501
 
         header_params = {}
 
@@ -641,43 +1827,160 @@ class ModelsStoreApi(object):
             _request_timeout=params.get('_request_timeout'),
             collection_formats=collection_formats)
 
-    def models_store_upload_model(self, body: 'V1UploadModelRequest', **kwargs) -> 'V1UploadModelResponse':  # noqa: E501
-        """UploadModel used to upload a new model version. It will either create a new top level model entry or reuse existing if an existing model is found. If version is not supplied, it will overwrite 'latest' version entry.  # noqa: E501
+    def models_store_update_model(self, body: 'ModelsModelIdBody', project_id: 'str', model_id: 'str', **kwargs) -> 'V1Model':  # noqa: E501
+        """models_store_update_model  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_update_model(body, project_id, model_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModelsModelIdBody body: (required)
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :return: V1Model
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+        kwargs['_return_http_data_only'] = True
+        if kwargs.get('async_req'):
+            return self.models_store_update_model_with_http_info(body, project_id, model_id, **kwargs)  # noqa: E501
+        else:
+            (data) = self.models_store_update_model_with_http_info(body, project_id, model_id, **kwargs)  # noqa: E501
+            return data
+
+    def models_store_update_model_with_http_info(self, body: 'ModelsModelIdBody', project_id: 'str', model_id: 'str', **kwargs) -> 'V1Model':  # noqa: E501
+        """models_store_update_model  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.models_store_update_model_with_http_info(body, project_id, model_id, async_req=True)
+        >>> result = thread.get()
+
+        :param async_req bool
+        :param ModelsModelIdBody body: (required)
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :return: V1Model
+                 If the method is called asynchronously,
+                 returns the request thread.
+        """
+
+        all_params = ['body', 'project_id', 'model_id']  # noqa: E501
+        all_params.append('async_req')
+        all_params.append('_return_http_data_only')
+        all_params.append('_preload_content')
+        all_params.append('_request_timeout')
+
+        params = locals()
+        for key, val in six.iteritems(params['kwargs']):
+            if key not in all_params:
+                raise TypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method models_store_update_model" % key
+                )
+            params[key] = val
+        del params['kwargs']
+        # verify the required parameter 'body' is set
+        if ('body' not in params or
+                params['body'] is None):
+            raise ValueError("Missing the required parameter `body` when calling `models_store_update_model`")  # noqa: E501
+        # verify the required parameter 'project_id' is set
+        if ('project_id' not in params or
+                params['project_id'] is None):
+            raise ValueError("Missing the required parameter `project_id` when calling `models_store_update_model`")  # noqa: E501
+        # verify the required parameter 'model_id' is set
+        if ('model_id' not in params or
+                params['model_id'] is None):
+            raise ValueError("Missing the required parameter `model_id` when calling `models_store_update_model`")  # noqa: E501
+
+        collection_formats = {}
+
+        path_params = {}
+        if 'project_id' in params:
+            path_params['projectId'] = params['project_id']  # noqa: E501
+        if 'model_id' in params:
+            path_params['modelId'] = params['model_id']  # noqa: E501
+
+        query_params = []
+
+        header_params = {}
+
+        form_params = []
+        local_var_files = {}
+
+        body_params = None
+        if 'body' in params:
+            body_params = params['body']
+        # 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(
+            '/v1/projects/{projectId}/models/{modelId}', 'PUT',
+            path_params,
+            query_params,
+            header_params,
+            body=body_params,
+            post_params=form_params,
+            files=local_var_files,
+            response_type='V1Model',  # noqa: E501
+            auth_settings=auth_settings,
+            async_req=params.get('async_req'),
+            _return_http_data_only=params.get('_return_http_data_only'),
+            _preload_content=params.get('_preload_content', True),
+            _request_timeout=params.get('_request_timeout'),
+            collection_formats=collection_formats)
+
+    def models_store_update_model_visibility(self, body: 'ModelIdVisibilityBody', project_id: 'str', model_id: 'str', **kwargs) -> 'V1UpdateModelVisibilityResponse':  # noqa: E501
+        """models_store_update_model_visibility  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.models_store_upload_model(body, async_req=True)
+        >>> thread = api.models_store_update_model_visibility(body, project_id, model_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param V1UploadModelRequest body: (required)
-        :return: V1UploadModelResponse
+        :param ModelIdVisibilityBody body: (required)
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :return: V1UpdateModelVisibilityResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
         if kwargs.get('async_req'):
-            return self.models_store_upload_model_with_http_info(body, **kwargs)  # noqa: E501
+            return self.models_store_update_model_visibility_with_http_info(body, project_id, model_id, **kwargs)  # noqa: E501
         else:
-            (data) = self.models_store_upload_model_with_http_info(body, **kwargs)  # noqa: E501
+            (data) = self.models_store_update_model_visibility_with_http_info(body, project_id, model_id, **kwargs)  # noqa: E501
             return data
 
-    def models_store_upload_model_with_http_info(self, body: 'V1UploadModelRequest', **kwargs) -> 'V1UploadModelResponse':  # noqa: E501
-        """UploadModel used to upload a new model version. It will either create a new top level model entry or reuse existing if an existing model is found. If version is not supplied, it will overwrite 'latest' version entry.  # noqa: E501
+    def models_store_update_model_visibility_with_http_info(self, body: 'ModelIdVisibilityBody', project_id: 'str', model_id: 'str', **kwargs) -> 'V1UpdateModelVisibilityResponse':  # noqa: E501
+        """models_store_update_model_visibility  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
-        >>> thread = api.models_store_upload_model_with_http_info(body, async_req=True)
+        >>> thread = api.models_store_update_model_visibility_with_http_info(body, project_id, model_id, async_req=True)
         >>> result = thread.get()
 
         :param async_req bool
-        :param V1UploadModelRequest body: (required)
-        :return: V1UploadModelResponse
+        :param ModelIdVisibilityBody body: (required)
+        :param str project_id: (required)
+        :param str model_id: (required)
+        :return: V1UpdateModelVisibilityResponse
                  If the method is called asynchronously,
                  returns the request thread.
         """
 
-        all_params = ['body']  # noqa: E501
+        all_params = ['body', 'project_id', 'model_id']  # noqa: E501
         all_params.append('async_req')
         all_params.append('_return_http_data_only')
         all_params.append('_preload_content')
@@ -688,18 +1991,30 @@ class ModelsStoreApi(object):
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method models_store_upload_model" % key
+                    " to method models_store_update_model_visibility" % key
                 )
             params[key] = val
         del params['kwargs']
         # verify the required parameter 'body' is set
         if ('body' not in params or
                 params['body'] is None):
-            raise ValueError("Missing the required parameter `body` when calling `models_store_upload_model`")  # noqa: E501
+            raise ValueError("Missing the required parameter `body` when calling `models_store_update_model_visibility`")  # noqa: E501
+        # verify the required parameter 'project_id' is set
+        if ('project_id' not in params or
+                params['project_id'] is None):
+            raise ValueError("Missing the required parameter `project_id` when calling `models_store_update_model_visibility`")  # noqa: E501
+        # verify the required parameter 'model_id' is set
+        if ('model_id' not in params or
+                params['model_id'] is None):
+            raise ValueError("Missing the required parameter `model_id` when calling `models_store_update_model_visibility`")  # noqa: E501
 
         collection_formats = {}
 
         path_params = {}
+        if 'project_id' in params:
+            path_params['projectId'] = params['project_id']  # noqa: E501
+        if 'model_id' in params:
+            path_params['modelId'] = params['model_id']  # noqa: E501
 
         query_params = []
 
@@ -723,14 +2038,14 @@ class ModelsStoreApi(object):
         auth_settings = []  # noqa: E501
 
         return self.api_client.call_api(
-            '/v1/models', 'POST',
+            '/v1/projects/{projectId}/models/{modelId}/visibility', 'PUT',
             path_params,
             query_params,
             header_params,
             body=body_params,
             post_params=form_params,
             files=local_var_files,
-            response_type='V1UploadModelResponse',  # noqa: E501
+            response_type='V1UpdateModelVisibilityResponse',  # noqa: E501
             auth_settings=auth_settings,
             async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),