rapidata 2.28.3__py3-none-any.whl → 2.28.5__py3-none-any.whl

rapidata/api_client/api/dataset_api.py

@@ -24,7 +24,6 @@ from rapidata.api_client.models.create_datapoint_from_text_sources_model import
 from rapidata.api_client.models.create_datapoint_from_urls_model import CreateDatapointFromUrlsModel
 from rapidata.api_client.models.create_datapoint_result import CreateDatapointResult
 from rapidata.api_client.models.create_datapoints_from_s3_bucket_model import CreateDatapointsFromS3BucketModel
-from rapidata.api_client.models.datapoint_metadata_model import DatapointMetadataModel
 from rapidata.api_client.models.datapoint_model_paged_result import DatapointModelPagedResult
 from rapidata.api_client.models.dataset_dataset_id_datapoints_post_request_metadata_inner import DatasetDatasetIdDatapointsPostRequestMetadataInner
 from rapidata.api_client.models.get_dataset_by_id_result import GetDatasetByIdResult
@@ -33,9 +32,7 @@ from rapidata.api_client.models.get_failed_datapoints_result import GetFailedDat
 from rapidata.api_client.models.import_from_file_result import ImportFromFileResult
 from rapidata.api_client.models.query_model import QueryModel
 from rapidata.api_client.models.update_dataset_name_model import UpdateDatasetNameModel
-from rapidata.api_client.models.upload_files_from_s3_bucket_model import UploadFilesFromS3BucketModel
 from rapidata.api_client.models.upload_from_s3_result import UploadFromS3Result
-from rapidata.api_client.models.upload_text_sources_to_dataset_model import UploadTextSourcesToDatasetModel
 
 from rapidata.api_client.api_client import ApiClient, RequestSerialized
 from rapidata.api_client.api_response import ApiResponse
@@ -56,10 +53,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_createdatapoint_post(
+    def dataset_dataset_id_datapoints_csv_post(
         self,
-        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
-        model: Optional[DatapointMetadataModel] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to import the datapoints to.")],
+        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -72,15 +69,14 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> CreateDatapointResult:
-        """(Deprecated) Creates a single datapoint.
+    ) -> ImportFromFileResult:
+        """Creates multiple datapoints from a csv.
 
-        If multiple files are uploaded, a multi asset datapoint will be created.
 
-        :param files:
-        :type files: List[bytearray]
-        :param model:
-        :type model: DatapointMetadataModel
+        :param dataset_id: The id of the dataset to import the datapoints to. (required)
+        :type dataset_id: str
+        :param file: The csv file to import.
+        :type file: bytearray
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -102,11 +98,10 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/createdatapoint is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_createdatapoint_post_serialize(
-            files=files,
-            model=model,
+        _param = self._dataset_dataset_id_datapoints_csv_post_serialize(
+            dataset_id=dataset_id,
+            file=file,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -114,7 +109,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
+            '200': "ImportFromFileResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -128,10 +123,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_createdatapoint_post_with_http_info(
+    def dataset_dataset_id_datapoints_csv_post_with_http_info(
         self,
-        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
-        model: Optional[DatapointMetadataModel] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to import the datapoints to.")],
+        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -144,15 +139,14 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[CreateDatapointResult]:
-        """(Deprecated) Creates a single datapoint.
+    ) -> ApiResponse[ImportFromFileResult]:
+        """Creates multiple datapoints from a csv.
 
-        If multiple files are uploaded, a multi asset datapoint will be created.
 
-        :param files:
-        :type files: List[bytearray]
-        :param model:
-        :type model: DatapointMetadataModel
+        :param dataset_id: The id of the dataset to import the datapoints to. (required)
+        :type dataset_id: str
+        :param file: The csv file to import.
+        :type file: bytearray
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -174,11 +168,10 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/createdatapoint is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_createdatapoint_post_serialize(
-            files=files,
-            model=model,
+        _param = self._dataset_dataset_id_datapoints_csv_post_serialize(
+            dataset_id=dataset_id,
+            file=file,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -186,7 +179,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
+            '200': "ImportFromFileResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -200,10 +193,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_createdatapoint_post_without_preload_content(
+    def dataset_dataset_id_datapoints_csv_post_without_preload_content(
         self,
-        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
-        model: Optional[DatapointMetadataModel] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to import the datapoints to.")],
+        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -217,14 +210,13 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """(Deprecated) Creates a single datapoint.
+        """Creates multiple datapoints from a csv.
 
-        If multiple files are uploaded, a multi asset datapoint will be created.
 
-        :param files:
-        :type files: List[bytearray]
-        :param model:
-        :type model: DatapointMetadataModel
+        :param dataset_id: The id of the dataset to import the datapoints to. (required)
+        :type dataset_id: str
+        :param file: The csv file to import.
+        :type file: bytearray
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -246,11 +238,10 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/createdatapoint is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_createdatapoint_post_serialize(
-            files=files,
-            model=model,
+        _param = self._dataset_dataset_id_datapoints_csv_post_serialize(
+            dataset_id=dataset_id,
+            file=file,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -258,7 +249,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
+            '200': "ImportFromFileResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -267,10 +258,10 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_createdatapoint_post_serialize(
+    def _dataset_dataset_id_datapoints_csv_post_serialize(
         self,
-        files,
-        model,
+        dataset_id,
+        file,
         _request_auth,
         _content_type,
         _headers,
@@ -280,7 +271,6 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
-            'files': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -293,13 +283,13 @@ class DatasetApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if dataset_id is not None:
+            _path_params['datasetId'] = dataset_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
-        if files is not None:
-            _files['files'] = files
-        if model is not None:
-            _form_params.append(('model', model))
+        if file is not None:
+            _files['file'] = file
         # process the body parameter
 
 
@@ -335,7 +325,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/dataset/createdatapoint',
+            resource_path='/dataset/{datasetId}/datapoints/csv',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -352,9 +342,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_creattextdatapoint_post(
+    def dataset_dataset_id_datapoints_failed_get(
         self,
-        upload_text_sources_to_dataset_model: Annotated[Optional[UploadTextSourcesToDatasetModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the failed datapoints of.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -367,13 +357,13 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> CreateDatapointResult:
-        """(Deprecated) Creates new datapoints from text sources.
+    ) -> GetFailedDatapointsResult:
+        """Gets a list of all datapoints that failed to upload.
 
-        If multiple text sources are uploaded, a new datapoint will be created for each text source.
+        A datapoint usually fails to upload when using a deferred upload mechanism such as when providing a URL and the URL is not accessible.
 
-        :param upload_text_sources_to_dataset_model: The body of the request.
-        :type upload_text_sources_to_dataset_model: UploadTextSourcesToDatasetModel
+        :param dataset_id: The id of the dataset to get the failed datapoints of. (required)
+        :type dataset_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -395,10 +385,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/creattextdatapoint is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_creattextdatapoint_post_serialize(
-            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
+        _param = self._dataset_dataset_id_datapoints_failed_get_serialize(
+            dataset_id=dataset_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -406,7 +395,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
+            '200': "GetFailedDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -420,9 +409,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_creattextdatapoint_post_with_http_info(
+    def dataset_dataset_id_datapoints_failed_get_with_http_info(
         self,
-        upload_text_sources_to_dataset_model: Annotated[Optional[UploadTextSourcesToDatasetModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the failed datapoints of.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -435,13 +424,13 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[CreateDatapointResult]:
-        """(Deprecated) Creates new datapoints from text sources.
+    ) -> ApiResponse[GetFailedDatapointsResult]:
+        """Gets a list of all datapoints that failed to upload.
 
-        If multiple text sources are uploaded, a new datapoint will be created for each text source.
+        A datapoint usually fails to upload when using a deferred upload mechanism such as when providing a URL and the URL is not accessible.
 
-        :param upload_text_sources_to_dataset_model: The body of the request.
-        :type upload_text_sources_to_dataset_model: UploadTextSourcesToDatasetModel
+        :param dataset_id: The id of the dataset to get the failed datapoints of. (required)
+        :type dataset_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -463,10 +452,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/creattextdatapoint is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_creattextdatapoint_post_serialize(
-            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
+        _param = self._dataset_dataset_id_datapoints_failed_get_serialize(
+            dataset_id=dataset_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -474,7 +462,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
+            '200': "GetFailedDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -488,9 +476,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_creattextdatapoint_post_without_preload_content(
+    def dataset_dataset_id_datapoints_failed_get_without_preload_content(
         self,
-        upload_text_sources_to_dataset_model: Annotated[Optional[UploadTextSourcesToDatasetModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the failed datapoints of.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -504,12 +492,12 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """(Deprecated) Creates new datapoints from text sources.
+        """Gets a list of all datapoints that failed to upload.
 
-        If multiple text sources are uploaded, a new datapoint will be created for each text source.
+        A datapoint usually fails to upload when using a deferred upload mechanism such as when providing a URL and the URL is not accessible.
 
-        :param upload_text_sources_to_dataset_model: The body of the request.
-        :type upload_text_sources_to_dataset_model: UploadTextSourcesToDatasetModel
+        :param dataset_id: The id of the dataset to get the failed datapoints of. (required)
+        :type dataset_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -531,10 +519,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/creattextdatapoint is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_creattextdatapoint_post_serialize(
-            upload_text_sources_to_dataset_model=upload_text_sources_to_dataset_model,
+        _param = self._dataset_dataset_id_datapoints_failed_get_serialize(
+            dataset_id=dataset_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -542,7 +529,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
+            '200': "GetFailedDatapointsResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -551,9 +538,9 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_creattextdatapoint_post_serialize(
+    def _dataset_dataset_id_datapoints_failed_get_serialize(
         self,
-        upload_text_sources_to_dataset_model,
+        dataset_id,
         _request_auth,
         _content_type,
         _headers,
@@ -575,12 +562,12 @@ class DatasetApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if dataset_id is not None:
+            _path_params['datasetId'] = dataset_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if upload_text_sources_to_dataset_model is not None:
-            _body_params = upload_text_sources_to_dataset_model
 
 
         # set the HTTP header `Accept`
@@ -593,21 +580,6 @@ class DatasetApi:
                 ]
             )
 
-        # set the HTTP header `Content-Type`
-        if _content_type:
-            _header_params['Content-Type'] = _content_type
-        else:
-            _default_content_type = (
-                self.api_client.select_header_content_type(
-                    [
-                        'application/json', 
-                        'text/json', 
-                        'application/*+json'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -616,8 +588,8 @@ class DatasetApi:
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/dataset/creattextdatapoint',
+            method='GET',
+            resource_path='/dataset/{datasetId}/datapoints/failed',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -634,10 +606,11 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_datapoints_csv_post(
+    def dataset_dataset_id_datapoints_files_post(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to import the datapoints to.")],
-        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        model: Optional[CreateDatapointFromFilesModel] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -650,14 +623,17 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ImportFromFileResult:
-        """Creates multiple datapoints from a csv.
+    ) -> CreateDatapointResult:
+        """Creates a single datapoint by uploading files.
 
+        If multiple files are uploaded, a multi asset datapoint will be created.
 
-        :param dataset_id: The id of the dataset to import the datapoints to. (required)
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
         :type dataset_id: str
-        :param file: The csv file to import.
-        :type file: bytearray
+        :param files:
+        :type files: List[bytearray]
+        :param model:
+        :type model: CreateDatapointFromFilesModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -680,9 +656,10 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_datapoints_csv_post_serialize(
+        _param = self._dataset_dataset_id_datapoints_files_post_serialize(
             dataset_id=dataset_id,
-            file=file,
+            files=files,
+            model=model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -690,7 +667,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ImportFromFileResult",
+            '200': "CreateDatapointResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -704,10 +681,11 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_datapoints_csv_post_with_http_info(
+    def dataset_dataset_id_datapoints_files_post_with_http_info(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to import the datapoints to.")],
-        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        model: Optional[CreateDatapointFromFilesModel] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -720,14 +698,17 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[ImportFromFileResult]:
-        """Creates multiple datapoints from a csv.
+    ) -> ApiResponse[CreateDatapointResult]:
+        """Creates a single datapoint by uploading files.
 
+        If multiple files are uploaded, a multi asset datapoint will be created.
 
-        :param dataset_id: The id of the dataset to import the datapoints to. (required)
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
         :type dataset_id: str
-        :param file: The csv file to import.
-        :type file: bytearray
+        :param files:
+        :type files: List[bytearray]
+        :param model:
+        :type model: CreateDatapointFromFilesModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -750,9 +731,10 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_datapoints_csv_post_serialize(
+        _param = self._dataset_dataset_id_datapoints_files_post_serialize(
             dataset_id=dataset_id,
-            file=file,
+            files=files,
+            model=model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -760,7 +742,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ImportFromFileResult",
+            '200': "CreateDatapointResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -774,10 +756,11 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_datapoints_csv_post_without_preload_content(
+    def dataset_dataset_id_datapoints_files_post_without_preload_content(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to import the datapoints to.")],
-        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
+        model: Optional[CreateDatapointFromFilesModel] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -791,13 +774,16 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Creates multiple datapoints from a csv.
+        """Creates a single datapoint by uploading files.
 
+        If multiple files are uploaded, a multi asset datapoint will be created.
 
-        :param dataset_id: The id of the dataset to import the datapoints to. (required)
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
         :type dataset_id: str
-        :param file: The csv file to import.
-        :type file: bytearray
+        :param files:
+        :type files: List[bytearray]
+        :param model:
+        :type model: CreateDatapointFromFilesModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -820,9 +806,10 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_datapoints_csv_post_serialize(
+        _param = self._dataset_dataset_id_datapoints_files_post_serialize(
             dataset_id=dataset_id,
-            file=file,
+            files=files,
+            model=model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -830,7 +817,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ImportFromFileResult",
+            '200': "CreateDatapointResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -839,10 +826,11 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_dataset_id_datapoints_csv_post_serialize(
+    def _dataset_dataset_id_datapoints_files_post_serialize(
         self,
         dataset_id,
-        file,
+        files,
+        model,
         _request_auth,
         _content_type,
         _headers,
@@ -852,6 +840,7 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
+            'files': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -869,8 +858,10 @@ class DatasetApi:
         # process the query parameters
         # process the header parameters
         # process the form parameters
-        if file is not None:
-            _files['file'] = file
+        if files is not None:
+            _files['files'] = files
+        if model is not None:
+            _form_params.append(('model', model))
         # process the body parameter
 
 
@@ -906,7 +897,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/dataset/{datasetId}/datapoints/csv',
+            resource_path='/dataset/{datasetId}/datapoints/files',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -923,9 +914,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_datapoints_failed_get(
+    def dataset_dataset_id_datapoints_get(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the failed datapoints of.")],
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the datapoints of.")],
+        request: Annotated[Optional[QueryModel], Field(description="The query model to filter, sort, and paginate the results.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -938,13 +930,14 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> GetFailedDatapointsResult:
-        """Gets a list of all datapoints that failed to upload.
+    ) -> DatapointModelPagedResult:
+        """Gets all datapoints of a dataset.
 
-        A datapoint usually fails to upload when using a deferred upload mechanism such as when providing a URL and the URL is not accessible.
 
-        :param dataset_id: The id of the dataset to get the failed datapoints of. (required)
+        :param dataset_id: The id of the dataset to get the datapoints of. (required)
         :type dataset_id: str
+        :param request: The query model to filter, sort, and paginate the results.
+        :type request: QueryModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -967,8 +960,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_datapoints_failed_get_serialize(
+        _param = self._dataset_dataset_id_datapoints_get_serialize(
             dataset_id=dataset_id,
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -976,7 +970,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetFailedDatapointsResult",
+            '200': "DatapointModelPagedResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -990,9 +984,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_datapoints_failed_get_with_http_info(
+    def dataset_dataset_id_datapoints_get_with_http_info(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the failed datapoints of.")],
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the datapoints of.")],
+        request: Annotated[Optional[QueryModel], Field(description="The query model to filter, sort, and paginate the results.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1005,13 +1000,14 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[GetFailedDatapointsResult]:
-        """Gets a list of all datapoints that failed to upload.
+    ) -> ApiResponse[DatapointModelPagedResult]:
+        """Gets all datapoints of a dataset.
 
-        A datapoint usually fails to upload when using a deferred upload mechanism such as when providing a URL and the URL is not accessible.
 
-        :param dataset_id: The id of the dataset to get the failed datapoints of. (required)
+        :param dataset_id: The id of the dataset to get the datapoints of. (required)
         :type dataset_id: str
+        :param request: The query model to filter, sort, and paginate the results.
+        :type request: QueryModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1034,8 +1030,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_datapoints_failed_get_serialize(
+        _param = self._dataset_dataset_id_datapoints_get_serialize(
             dataset_id=dataset_id,
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1043,7 +1040,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetFailedDatapointsResult",
+            '200': "DatapointModelPagedResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1057,9 +1054,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_datapoints_failed_get_without_preload_content(
+    def dataset_dataset_id_datapoints_get_without_preload_content(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the failed datapoints of.")],
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the datapoints of.")],
+        request: Annotated[Optional[QueryModel], Field(description="The query model to filter, sort, and paginate the results.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1073,12 +1071,13 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Gets a list of all datapoints that failed to upload.
+        """Gets all datapoints of a dataset.
 
-        A datapoint usually fails to upload when using a deferred upload mechanism such as when providing a URL and the URL is not accessible.
 
-        :param dataset_id: The id of the dataset to get the failed datapoints of. (required)
+        :param dataset_id: The id of the dataset to get the datapoints of. (required)
         :type dataset_id: str
+        :param request: The query model to filter, sort, and paginate the results.
+        :type request: QueryModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1101,8 +1100,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_datapoints_failed_get_serialize(
+        _param = self._dataset_dataset_id_datapoints_get_serialize(
             dataset_id=dataset_id,
+            request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1110,7 +1110,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetFailedDatapointsResult",
+            '200': "DatapointModelPagedResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1119,9 +1119,10 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_dataset_id_datapoints_failed_get_serialize(
+    def _dataset_dataset_id_datapoints_get_serialize(
         self,
         dataset_id,
+        request,
         _request_auth,
         _content_type,
         _headers,
@@ -1146,6 +1147,10 @@ class DatasetApi:
         if dataset_id is not None:
             _path_params['datasetId'] = dataset_id
         # process the query parameters
+        if request is not None:
+            
+            _query_params.append(('request', request))
+            
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -1170,7 +1175,7 @@ class DatasetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/dataset/{datasetId}/datapoints/failed',
+            resource_path='/dataset/{datasetId}/datapoints',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1187,11 +1192,14 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_datapoints_files_post(
+    def dataset_dataset_id_datapoints_post(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
-        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
-        model: Optional[CreateDatapointFromFilesModel] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset")],
+        file: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The files to upload from the local storage. Must be either images or videos.")] = None,
+        text: Annotated[Optional[List[StrictStr]], Field(description="The texts to upload. The length limit is set at 256 characters per text.")] = None,
+        url: Annotated[Optional[List[StrictStr]], Field(description="Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>")] = None,
+        metadata: Annotated[Optional[List[DatasetDatasetIdDatapointsPostRequestMetadataInner]], Field(description="Optional metadata to attach to the datapoint.")] = None,
+        sort_index: Annotated[Optional[StrictInt], Field(description="The index will be used to keep the datapoints in order. Useful if upload is parallelized")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1205,16 +1213,22 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> CreateDatapointResult:
-        """Creates a single datapoint by uploading files.
+        """Creates a new datapoint from multiple possible sources.
 
-        If multiple files are uploaded, a multi asset datapoint will be created.
+        Multiple files, texts, and urls can be provided. If multiple files are provided, a multi-asset datapoint will be created, meaning that all sources provided will be stored as sub-assets of the datapoint.              If multiple datapoints are desired, one should not pass in multiple files, texts, or urls, instead, one should call this endpoint multiple times with the desired file, text, or url per datapoint.              The request must be a multipart form request, where each parameter is sent as a separate part. The files, texts, and urls can be mixed and matched as needed, however, at least one of them must be provided, and one should make sure that mixing them makes sense for the dataset.
 
-        :param dataset_id: The id of the dataset to create the datapoint in. (required)
+        :param dataset_id: The id of the dataset (required)
         :type dataset_id: str
-        :param files:
-        :type files: List[bytearray]
-        :param model:
-        :type model: CreateDatapointFromFilesModel
+        :param file: The files to upload from the local storage. Must be either images or videos.
+        :type file: List[bytearray]
+        :param text: The texts to upload. The length limit is set at 256 characters per text.
+        :type text: List[str]
+        :param url: Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>
+        :type url: List[str]
+        :param metadata: Optional metadata to attach to the datapoint.
+        :type metadata: List[DatasetDatasetIdDatapointsPostRequestMetadataInner]
+        :param sort_index: The index will be used to keep the datapoints in order. Useful if upload is parallelized
+        :type sort_index: int
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1237,10 +1251,13 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_datapoints_files_post_serialize(
+        _param = self._dataset_dataset_id_datapoints_post_serialize(
             dataset_id=dataset_id,
-            files=files,
-            model=model,
+            file=file,
+            text=text,
+            url=url,
+            metadata=metadata,
+            sort_index=sort_index,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1262,11 +1279,14 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_datapoints_files_post_with_http_info(
+    def dataset_dataset_id_datapoints_post_with_http_info(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
-        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
-        model: Optional[CreateDatapointFromFilesModel] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset")],
+        file: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The files to upload from the local storage. Must be either images or videos.")] = None,
+        text: Annotated[Optional[List[StrictStr]], Field(description="The texts to upload. The length limit is set at 256 characters per text.")] = None,
+        url: Annotated[Optional[List[StrictStr]], Field(description="Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>")] = None,
+        metadata: Annotated[Optional[List[DatasetDatasetIdDatapointsPostRequestMetadataInner]], Field(description="Optional metadata to attach to the datapoint.")] = None,
+        sort_index: Annotated[Optional[StrictInt], Field(description="The index will be used to keep the datapoints in order. Useful if upload is parallelized")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1280,1824 +1300,22 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[CreateDatapointResult]:
-        """Creates a single datapoint by uploading files.
-
-        If multiple files are uploaded, a multi asset datapoint will be created.
-
-        :param dataset_id: The id of the dataset to create the datapoint in. (required)
-        :type dataset_id: str
-        :param files:
-        :type files: List[bytearray]
-        :param model:
-        :type model: CreateDatapointFromFilesModel
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_files_post_serialize(
-            dataset_id=dataset_id,
-            files=files,
-            model=model,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        )
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_files_post_without_preload_content(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
-        files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
-        model: Optional[CreateDatapointFromFilesModel] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RESTResponseType:
-        """Creates a single datapoint by uploading files.
+        """Creates a new datapoint from multiple possible sources.
 
-        If multiple files are uploaded, a multi asset datapoint will be created.
+        Multiple files, texts, and urls can be provided. If multiple files are provided, a multi-asset datapoint will be created, meaning that all sources provided will be stored as sub-assets of the datapoint.              If multiple datapoints are desired, one should not pass in multiple files, texts, or urls, instead, one should call this endpoint multiple times with the desired file, text, or url per datapoint.              The request must be a multipart form request, where each parameter is sent as a separate part. The files, texts, and urls can be mixed and matched as needed, however, at least one of them must be provided, and one should make sure that mixing them makes sense for the dataset.
 
-        :param dataset_id: The id of the dataset to create the datapoint in. (required)
-        :type dataset_id: str
-        :param files:
-        :type files: List[bytearray]
-        :param model:
-        :type model: CreateDatapointFromFilesModel
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_files_post_serialize(
-            dataset_id=dataset_id,
-            files=files,
-            model=model,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _dataset_dataset_id_datapoints_files_post_serialize(
-        self,
-        dataset_id,
-        files,
-        model,
-        _request_auth,
-        _content_type,
-        _headers,
-        _host_index,
-    ) -> RequestSerialized:
-
-        _host = None
-
-        _collection_formats: Dict[str, str] = {
-            'files': 'multi',
-        }
-
-        _path_params: Dict[str, str] = {}
-        _query_params: List[Tuple[str, str]] = []
-        _header_params: Dict[str, Optional[str]] = _headers or {}
-        _form_params: List[Tuple[str, str]] = []
-        _files: Dict[
-            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
-        ] = {}
-        _body_params: Optional[bytes] = None
-
-        # process the path parameters
-        if dataset_id is not None:
-            _path_params['datasetId'] = dataset_id
-        # process the query parameters
-        # process the header parameters
-        # process the form parameters
-        if files is not None:
-            _files['files'] = files
-        if model is not None:
-            _form_params.append(('model', model))
-        # process the body parameter
-
-
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'text/plain', 
-                    'application/json', 
-                    'text/json'
-                ]
-            )
-
-        # set the HTTP header `Content-Type`
-        if _content_type:
-            _header_params['Content-Type'] = _content_type
-        else:
-            _default_content_type = (
-                self.api_client.select_header_content_type(
-                    [
-                        'multipart/form-data'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
-
-        # authentication setting
-        _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
-        ]
-
-        return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/dataset/{datasetId}/datapoints/files',
-            path_params=_path_params,
-            query_params=_query_params,
-            header_params=_header_params,
-            body=_body_params,
-            post_params=_form_params,
-            files=_files,
-            auth_settings=_auth_settings,
-            collection_formats=_collection_formats,
-            _host=_host,
-            _request_auth=_request_auth
-        )
-
-
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_get(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the datapoints of.")],
-        request: Annotated[Optional[QueryModel], Field(description="The query model to filter, sort, and paginate the results.")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> DatapointModelPagedResult:
-        """Gets all datapoints of a dataset.
-
-
-        :param dataset_id: The id of the dataset to get the datapoints of. (required)
-        :type dataset_id: str
-        :param request: The query model to filter, sort, and paginate the results.
-        :type request: QueryModel
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_get_serialize(
-            dataset_id=dataset_id,
-            request=request,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "DatapointModelPagedResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        ).data
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_get_with_http_info(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the datapoints of.")],
-        request: Annotated[Optional[QueryModel], Field(description="The query model to filter, sort, and paginate the results.")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[DatapointModelPagedResult]:
-        """Gets all datapoints of a dataset.
-
-
-        :param dataset_id: The id of the dataset to get the datapoints of. (required)
-        :type dataset_id: str
-        :param request: The query model to filter, sort, and paginate the results.
-        :type request: QueryModel
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_get_serialize(
-            dataset_id=dataset_id,
-            request=request,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "DatapointModelPagedResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        )
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_get_without_preload_content(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the datapoints of.")],
-        request: Annotated[Optional[QueryModel], Field(description="The query model to filter, sort, and paginate the results.")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RESTResponseType:
-        """Gets all datapoints of a dataset.
-
-
-        :param dataset_id: The id of the dataset to get the datapoints of. (required)
-        :type dataset_id: str
-        :param request: The query model to filter, sort, and paginate the results.
-        :type request: QueryModel
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_get_serialize(
-            dataset_id=dataset_id,
-            request=request,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "DatapointModelPagedResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _dataset_dataset_id_datapoints_get_serialize(
-        self,
-        dataset_id,
-        request,
-        _request_auth,
-        _content_type,
-        _headers,
-        _host_index,
-    ) -> RequestSerialized:
-
-        _host = None
-
-        _collection_formats: Dict[str, str] = {
-        }
-
-        _path_params: Dict[str, str] = {}
-        _query_params: List[Tuple[str, str]] = []
-        _header_params: Dict[str, Optional[str]] = _headers or {}
-        _form_params: List[Tuple[str, str]] = []
-        _files: Dict[
-            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
-        ] = {}
-        _body_params: Optional[bytes] = None
-
-        # process the path parameters
-        if dataset_id is not None:
-            _path_params['datasetId'] = dataset_id
-        # process the query parameters
-        if request is not None:
-            
-            _query_params.append(('request', request))
-            
-        # process the header parameters
-        # process the form parameters
-        # process the body parameter
-
-
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'text/plain', 
-                    'application/json', 
-                    'text/json'
-                ]
-            )
-
-
-        # authentication setting
-        _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
-        ]
-
-        return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/dataset/{datasetId}/datapoints',
-            path_params=_path_params,
-            query_params=_query_params,
-            header_params=_header_params,
-            body=_body_params,
-            post_params=_form_params,
-            files=_files,
-            auth_settings=_auth_settings,
-            collection_formats=_collection_formats,
-            _host=_host,
-            _request_auth=_request_auth
-        )
-
-
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_post(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset")],
-        file: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The files to upload from the local storage. Must be either images or videos.")] = None,
-        text: Annotated[Optional[List[StrictStr]], Field(description="The texts to upload. The length limit is set at 256 characters per text.")] = None,
-        url: Annotated[Optional[List[StrictStr]], Field(description="Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>")] = None,
-        metadata: Annotated[Optional[List[DatasetDatasetIdDatapointsPostRequestMetadataInner]], Field(description="Optional metadata to attach to the datapoint.")] = None,
-        sort_index: Annotated[Optional[StrictInt], Field(description="The index will be used to keep the datapoints in order. Useful if upload is parallelized")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> CreateDatapointResult:
-        """Creates a new datapoint from multiple possible sources.
-
-        Multiple files, texts, and urls can be provided. If multiple files are provided, a multi-asset datapoint will be created, meaning that all sources provided will be stored as sub-assets of the datapoint.              If multiple datapoints are desired, one should not pass in multiple files, texts, or urls, instead, one should call this endpoint multiple times with the desired file, text, or url per datapoint.              The request must be a multipart form request, where each parameter is sent as a separate part. The files, texts, and urls can be mixed and matched as needed, however, at least one of them must be provided, and one should make sure that mixing them makes sense for the dataset.
-
-        :param dataset_id: The id of the dataset (required)
-        :type dataset_id: str
-        :param file: The files to upload from the local storage. Must be either images or videos.
-        :type file: List[bytearray]
-        :param text: The texts to upload. The length limit is set at 256 characters per text.
-        :type text: List[str]
-        :param url: Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>
-        :type url: List[str]
-        :param metadata: Optional metadata to attach to the datapoint.
-        :type metadata: List[DatasetDatasetIdDatapointsPostRequestMetadataInner]
-        :param sort_index: The index will be used to keep the datapoints in order. Useful if upload is parallelized
-        :type sort_index: int
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_post_serialize(
-            dataset_id=dataset_id,
-            file=file,
-            text=text,
-            url=url,
-            metadata=metadata,
-            sort_index=sort_index,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        ).data
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_post_with_http_info(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset")],
-        file: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The files to upload from the local storage. Must be either images or videos.")] = None,
-        text: Annotated[Optional[List[StrictStr]], Field(description="The texts to upload. The length limit is set at 256 characters per text.")] = None,
-        url: Annotated[Optional[List[StrictStr]], Field(description="Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>")] = None,
-        metadata: Annotated[Optional[List[DatasetDatasetIdDatapointsPostRequestMetadataInner]], Field(description="Optional metadata to attach to the datapoint.")] = None,
-        sort_index: Annotated[Optional[StrictInt], Field(description="The index will be used to keep the datapoints in order. Useful if upload is parallelized")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[CreateDatapointResult]:
-        """Creates a new datapoint from multiple possible sources.
-
-        Multiple files, texts, and urls can be provided. If multiple files are provided, a multi-asset datapoint will be created, meaning that all sources provided will be stored as sub-assets of the datapoint.              If multiple datapoints are desired, one should not pass in multiple files, texts, or urls, instead, one should call this endpoint multiple times with the desired file, text, or url per datapoint.              The request must be a multipart form request, where each parameter is sent as a separate part. The files, texts, and urls can be mixed and matched as needed, however, at least one of them must be provided, and one should make sure that mixing them makes sense for the dataset.
-
-        :param dataset_id: The id of the dataset (required)
-        :type dataset_id: str
-        :param file: The files to upload from the local storage. Must be either images or videos.
-        :type file: List[bytearray]
-        :param text: The texts to upload. The length limit is set at 256 characters per text.
-        :type text: List[str]
-        :param url: Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>
-        :type url: List[str]
-        :param metadata: Optional metadata to attach to the datapoint.
-        :type metadata: List[DatasetDatasetIdDatapointsPostRequestMetadataInner]
-        :param sort_index: The index will be used to keep the datapoints in order. Useful if upload is parallelized
-        :type sort_index: int
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_post_serialize(
-            dataset_id=dataset_id,
-            file=file,
-            text=text,
-            url=url,
-            metadata=metadata,
-            sort_index=sort_index,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        )
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_post_without_preload_content(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset")],
-        file: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The files to upload from the local storage. Must be either images or videos.")] = None,
-        text: Annotated[Optional[List[StrictStr]], Field(description="The texts to upload. The length limit is set at 256 characters per text.")] = None,
-        url: Annotated[Optional[List[StrictStr]], Field(description="Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>")] = None,
-        metadata: Annotated[Optional[List[DatasetDatasetIdDatapointsPostRequestMetadataInner]], Field(description="Optional metadata to attach to the datapoint.")] = None,
-        sort_index: Annotated[Optional[StrictInt], Field(description="The index will be used to keep the datapoints in order. Useful if upload is parallelized")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RESTResponseType:
-        """Creates a new datapoint from multiple possible sources.
-
-        Multiple files, texts, and urls can be provided. If multiple files are provided, a multi-asset datapoint will be created, meaning that all sources provided will be stored as sub-assets of the datapoint.              If multiple datapoints are desired, one should not pass in multiple files, texts, or urls, instead, one should call this endpoint multiple times with the desired file, text, or url per datapoint.              The request must be a multipart form request, where each parameter is sent as a separate part. The files, texts, and urls can be mixed and matched as needed, however, at least one of them must be provided, and one should make sure that mixing them makes sense for the dataset.
-
-        :param dataset_id: The id of the dataset (required)
-        :type dataset_id: str
-        :param file: The files to upload from the local storage. Must be either images or videos.
-        :type file: List[bytearray]
-        :param text: The texts to upload. The length limit is set at 256 characters per text.
-        :type text: List[str]
-        :param url: Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>
-        :type url: List[str]
-        :param metadata: Optional metadata to attach to the datapoint.
-        :type metadata: List[DatasetDatasetIdDatapointsPostRequestMetadataInner]
-        :param sort_index: The index will be used to keep the datapoints in order. Useful if upload is parallelized
-        :type sort_index: int
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_post_serialize(
-            dataset_id=dataset_id,
-            file=file,
-            text=text,
-            url=url,
-            metadata=metadata,
-            sort_index=sort_index,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _dataset_dataset_id_datapoints_post_serialize(
-        self,
-        dataset_id,
-        file,
-        text,
-        url,
-        metadata,
-        sort_index,
-        _request_auth,
-        _content_type,
-        _headers,
-        _host_index,
-    ) -> RequestSerialized:
-
-        _host = None
-
-        _collection_formats: Dict[str, str] = {
-            'file': 'csv',
-            'text': 'multi',
-            'url': 'multi',
-            'metadata': 'multi',
-        }
-
-        _path_params: Dict[str, str] = {}
-        _query_params: List[Tuple[str, str]] = []
-        _header_params: Dict[str, Optional[str]] = _headers or {}
-        _form_params: List[Tuple[str, str]] = []
-        _files: Dict[
-            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
-        ] = {}
-        _body_params: Optional[bytes] = None
-
-        # process the path parameters
-        if dataset_id is not None:
-            _path_params['datasetId'] = dataset_id
-        # process the query parameters
-        # process the header parameters
-        # process the form parameters
-        if file is not None:
-            _files['file'] = file
-        if text is not None:
-            _form_params.append(('text', text))
-        if url is not None:
-            _form_params.append(('url', url))
-        if metadata is not None:
-            _form_params.append(('metadata', metadata))
-        if sort_index is not None:
-            _form_params.append(('sortIndex', sort_index))
-        # process the body parameter
-
-
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'text/plain', 
-                    'application/json', 
-                    'text/json'
-                ]
-            )
-
-        # set the HTTP header `Content-Type`
-        if _content_type:
-            _header_params['Content-Type'] = _content_type
-        else:
-            _default_content_type = (
-                self.api_client.select_header_content_type(
-                    [
-                        'multipart/form-data'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
-
-        # authentication setting
-        _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
-        ]
-
-        return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/dataset/{datasetId}/datapoints',
-            path_params=_path_params,
-            query_params=_query_params,
-            header_params=_header_params,
-            body=_body_params,
-            post_params=_form_params,
-            files=_files,
-            auth_settings=_auth_settings,
-            collection_formats=_collection_formats,
-            _host=_host,
-            _request_auth=_request_auth
-        )
-
-
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_s3_post(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to upload the files to.")],
-        create_datapoints_from_s3_bucket_model: Annotated[Optional[CreateDatapointsFromS3BucketModel], Field(description="The body of the request.")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> UploadFromS3Result:
-        """Uploads files from an S3 bucket to a dataset.
-
-        A new datapoint will be created for each file in the bucket.
-
-        :param dataset_id: The id of the dataset to upload the files to. (required)
-        :type dataset_id: str
-        :param create_datapoints_from_s3_bucket_model: The body of the request.
-        :type create_datapoints_from_s3_bucket_model: CreateDatapointsFromS3BucketModel
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_s3_post_serialize(
-            dataset_id=dataset_id,
-            create_datapoints_from_s3_bucket_model=create_datapoints_from_s3_bucket_model,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadFromS3Result",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        ).data
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_s3_post_with_http_info(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to upload the files to.")],
-        create_datapoints_from_s3_bucket_model: Annotated[Optional[CreateDatapointsFromS3BucketModel], Field(description="The body of the request.")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[UploadFromS3Result]:
-        """Uploads files from an S3 bucket to a dataset.
-
-        A new datapoint will be created for each file in the bucket.
-
-        :param dataset_id: The id of the dataset to upload the files to. (required)
-        :type dataset_id: str
-        :param create_datapoints_from_s3_bucket_model: The body of the request.
-        :type create_datapoints_from_s3_bucket_model: CreateDatapointsFromS3BucketModel
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_s3_post_serialize(
-            dataset_id=dataset_id,
-            create_datapoints_from_s3_bucket_model=create_datapoints_from_s3_bucket_model,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadFromS3Result",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        )
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_s3_post_without_preload_content(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to upload the files to.")],
-        create_datapoints_from_s3_bucket_model: Annotated[Optional[CreateDatapointsFromS3BucketModel], Field(description="The body of the request.")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RESTResponseType:
-        """Uploads files from an S3 bucket to a dataset.
-
-        A new datapoint will be created for each file in the bucket.
-
-        :param dataset_id: The id of the dataset to upload the files to. (required)
-        :type dataset_id: str
-        :param create_datapoints_from_s3_bucket_model: The body of the request.
-        :type create_datapoints_from_s3_bucket_model: CreateDatapointsFromS3BucketModel
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_s3_post_serialize(
-            dataset_id=dataset_id,
-            create_datapoints_from_s3_bucket_model=create_datapoints_from_s3_bucket_model,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadFromS3Result",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _dataset_dataset_id_datapoints_s3_post_serialize(
-        self,
-        dataset_id,
-        create_datapoints_from_s3_bucket_model,
-        _request_auth,
-        _content_type,
-        _headers,
-        _host_index,
-    ) -> RequestSerialized:
-
-        _host = None
-
-        _collection_formats: Dict[str, str] = {
-        }
-
-        _path_params: Dict[str, str] = {}
-        _query_params: List[Tuple[str, str]] = []
-        _header_params: Dict[str, Optional[str]] = _headers or {}
-        _form_params: List[Tuple[str, str]] = []
-        _files: Dict[
-            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
-        ] = {}
-        _body_params: Optional[bytes] = None
-
-        # process the path parameters
-        if dataset_id is not None:
-            _path_params['datasetId'] = dataset_id
-        # process the query parameters
-        # process the header parameters
-        # process the form parameters
-        # process the body parameter
-        if create_datapoints_from_s3_bucket_model is not None:
-            _body_params = create_datapoints_from_s3_bucket_model
-
-
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'text/plain', 
-                    'application/json', 
-                    'text/json'
-                ]
-            )
-
-        # set the HTTP header `Content-Type`
-        if _content_type:
-            _header_params['Content-Type'] = _content_type
-        else:
-            _default_content_type = (
-                self.api_client.select_header_content_type(
-                    [
-                        'application/json', 
-                        'text/json', 
-                        'application/*+json'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
-
-        # authentication setting
-        _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
-        ]
-
-        return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/dataset/{datasetId}/datapoints/s3',
-            path_params=_path_params,
-            query_params=_query_params,
-            header_params=_header_params,
-            body=_body_params,
-            post_params=_form_params,
-            files=_files,
-            auth_settings=_auth_settings,
-            collection_formats=_collection_formats,
-            _host=_host,
-            _request_auth=_request_auth
-        )
-
-
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_texts_post(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
-        create_datapoint_from_text_sources_model: Annotated[Optional[CreateDatapointFromTextSourcesModel], Field(description="The body of the request.")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> CreateDatapointResult:
-        """Creates a single datapoint from text sources.
-
-        If multiple text sources are uploaded, a multi asset datapoint will be created.
-
-        :param dataset_id: The id of the dataset to create the datapoint in. (required)
-        :type dataset_id: str
-        :param create_datapoint_from_text_sources_model: The body of the request.
-        :type create_datapoint_from_text_sources_model: CreateDatapointFromTextSourcesModel
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_texts_post_serialize(
-            dataset_id=dataset_id,
-            create_datapoint_from_text_sources_model=create_datapoint_from_text_sources_model,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        ).data
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_texts_post_with_http_info(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
-        create_datapoint_from_text_sources_model: Annotated[Optional[CreateDatapointFromTextSourcesModel], Field(description="The body of the request.")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[CreateDatapointResult]:
-        """Creates a single datapoint from text sources.
-
-        If multiple text sources are uploaded, a multi asset datapoint will be created.
-
-        :param dataset_id: The id of the dataset to create the datapoint in. (required)
-        :type dataset_id: str
-        :param create_datapoint_from_text_sources_model: The body of the request.
-        :type create_datapoint_from_text_sources_model: CreateDatapointFromTextSourcesModel
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_texts_post_serialize(
-            dataset_id=dataset_id,
-            create_datapoint_from_text_sources_model=create_datapoint_from_text_sources_model,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        )
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_texts_post_without_preload_content(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
-        create_datapoint_from_text_sources_model: Annotated[Optional[CreateDatapointFromTextSourcesModel], Field(description="The body of the request.")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RESTResponseType:
-        """Creates a single datapoint from text sources.
-
-        If multiple text sources are uploaded, a multi asset datapoint will be created.
-
-        :param dataset_id: The id of the dataset to create the datapoint in. (required)
-        :type dataset_id: str
-        :param create_datapoint_from_text_sources_model: The body of the request.
-        :type create_datapoint_from_text_sources_model: CreateDatapointFromTextSourcesModel
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_texts_post_serialize(
-            dataset_id=dataset_id,
-            create_datapoint_from_text_sources_model=create_datapoint_from_text_sources_model,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _dataset_dataset_id_datapoints_texts_post_serialize(
-        self,
-        dataset_id,
-        create_datapoint_from_text_sources_model,
-        _request_auth,
-        _content_type,
-        _headers,
-        _host_index,
-    ) -> RequestSerialized:
-
-        _host = None
-
-        _collection_formats: Dict[str, str] = {
-        }
-
-        _path_params: Dict[str, str] = {}
-        _query_params: List[Tuple[str, str]] = []
-        _header_params: Dict[str, Optional[str]] = _headers or {}
-        _form_params: List[Tuple[str, str]] = []
-        _files: Dict[
-            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
-        ] = {}
-        _body_params: Optional[bytes] = None
-
-        # process the path parameters
-        if dataset_id is not None:
-            _path_params['datasetId'] = dataset_id
-        # process the query parameters
-        # process the header parameters
-        # process the form parameters
-        # process the body parameter
-        if create_datapoint_from_text_sources_model is not None:
-            _body_params = create_datapoint_from_text_sources_model
-
-
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'text/plain', 
-                    'application/json', 
-                    'text/json'
-                ]
-            )
-
-        # set the HTTP header `Content-Type`
-        if _content_type:
-            _header_params['Content-Type'] = _content_type
-        else:
-            _default_content_type = (
-                self.api_client.select_header_content_type(
-                    [
-                        'application/json', 
-                        'text/json', 
-                        'application/*+json'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
-
-        # authentication setting
-        _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
-        ]
-
-        return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/dataset/{datasetId}/datapoints/texts',
-            path_params=_path_params,
-            query_params=_query_params,
-            header_params=_header_params,
-            body=_body_params,
-            post_params=_form_params,
-            files=_files,
-            auth_settings=_auth_settings,
-            collection_formats=_collection_formats,
-            _host=_host,
-            _request_auth=_request_auth
-        )
-
-
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_urls_post(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
-        create_datapoint_from_urls_model: Annotated[Optional[CreateDatapointFromUrlsModel], Field(description="The body of the request.")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> CreateDatapointResult:
-        """Creates a single datapoint where the assets are fetched from the specified urls.
-
-        Passing in multiple urls will create a single datapoint with a MultiAsset. Each url will be fetched and stored as a sub-asset of the MultiAsset. <para /> If any of the urls are not accessible, the request will fail.
-
-        :param dataset_id: The id of the dataset to create the datapoint in. (required)
-        :type dataset_id: str
-        :param create_datapoint_from_urls_model: The body of the request.
-        :type create_datapoint_from_urls_model: CreateDatapointFromUrlsModel
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_urls_post_serialize(
-            dataset_id=dataset_id,
-            create_datapoint_from_urls_model=create_datapoint_from_urls_model,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        ).data
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_urls_post_with_http_info(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
-        create_datapoint_from_urls_model: Annotated[Optional[CreateDatapointFromUrlsModel], Field(description="The body of the request.")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[CreateDatapointResult]:
-        """Creates a single datapoint where the assets are fetched from the specified urls.
-
-        Passing in multiple urls will create a single datapoint with a MultiAsset. Each url will be fetched and stored as a sub-asset of the MultiAsset. <para /> If any of the urls are not accessible, the request will fail.
-
-        :param dataset_id: The id of the dataset to create the datapoint in. (required)
-        :type dataset_id: str
-        :param create_datapoint_from_urls_model: The body of the request.
-        :type create_datapoint_from_urls_model: CreateDatapointFromUrlsModel
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_urls_post_serialize(
-            dataset_id=dataset_id,
-            create_datapoint_from_urls_model=create_datapoint_from_urls_model,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        )
-
-
-    @validate_call
-    def dataset_dataset_id_datapoints_urls_post_without_preload_content(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
-        create_datapoint_from_urls_model: Annotated[Optional[CreateDatapointFromUrlsModel], Field(description="The body of the request.")] = None,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RESTResponseType:
-        """Creates a single datapoint where the assets are fetched from the specified urls.
-
-        Passing in multiple urls will create a single datapoint with a MultiAsset. Each url will be fetched and stored as a sub-asset of the MultiAsset. <para /> If any of the urls are not accessible, the request will fail.
-
-        :param dataset_id: The id of the dataset to create the datapoint in. (required)
-        :type dataset_id: str
-        :param create_datapoint_from_urls_model: The body of the request.
-        :type create_datapoint_from_urls_model: CreateDatapointFromUrlsModel
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_datapoints_urls_post_serialize(
-            dataset_id=dataset_id,
-            create_datapoint_from_urls_model=create_datapoint_from_urls_model,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CreateDatapointResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _dataset_dataset_id_datapoints_urls_post_serialize(
-        self,
-        dataset_id,
-        create_datapoint_from_urls_model,
-        _request_auth,
-        _content_type,
-        _headers,
-        _host_index,
-    ) -> RequestSerialized:
-
-        _host = None
-
-        _collection_formats: Dict[str, str] = {
-        }
-
-        _path_params: Dict[str, str] = {}
-        _query_params: List[Tuple[str, str]] = []
-        _header_params: Dict[str, Optional[str]] = _headers or {}
-        _form_params: List[Tuple[str, str]] = []
-        _files: Dict[
-            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
-        ] = {}
-        _body_params: Optional[bytes] = None
-
-        # process the path parameters
-        if dataset_id is not None:
-            _path_params['datasetId'] = dataset_id
-        # process the query parameters
-        # process the header parameters
-        # process the form parameters
-        # process the body parameter
-        if create_datapoint_from_urls_model is not None:
-            _body_params = create_datapoint_from_urls_model
-
-
-        # set the HTTP header `Accept`
-        if 'Accept' not in _header_params:
-            _header_params['Accept'] = self.api_client.select_header_accept(
-                [
-                    'text/plain', 
-                    'application/json', 
-                    'text/json'
-                ]
-            )
-
-        # set the HTTP header `Content-Type`
-        if _content_type:
-            _header_params['Content-Type'] = _content_type
-        else:
-            _default_content_type = (
-                self.api_client.select_header_content_type(
-                    [
-                        'application/json', 
-                        'text/json', 
-                        'application/*+json'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
-
-        # authentication setting
-        _auth_settings: List[str] = [
-            'bearer', 
-            'oauth2'
-        ]
-
-        return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/dataset/{datasetId}/datapoints/urls',
-            path_params=_path_params,
-            query_params=_query_params,
-            header_params=_header_params,
-            body=_body_params,
-            post_params=_form_params,
-            files=_files,
-            auth_settings=_auth_settings,
-            collection_formats=_collection_formats,
-            _host=_host,
-            _request_auth=_request_auth
-        )
-
-
-
-
-    @validate_call
-    def dataset_dataset_id_get(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get.")],
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> GetDatasetByIdResult:
-        """Gets a dataset by its id.
-
-
-        :param dataset_id: The id of the dataset to get. (required)
-        :type dataset_id: str
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._dataset_dataset_id_get_serialize(
-            dataset_id=dataset_id,
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetByIdResult",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        ).data
-
-
-    @validate_call
-    def dataset_dataset_id_get_with_http_info(
-        self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get.")],
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[GetDatasetByIdResult]:
-        """Gets a dataset by its id.
-
-
-        :param dataset_id: The id of the dataset to get. (required)
+        :param dataset_id: The id of the dataset (required)
         :type dataset_id: str
+        :param file: The files to upload from the local storage. Must be either images or videos.
+        :type file: List[bytearray]
+        :param text: The texts to upload. The length limit is set at 256 characters per text.
+        :type text: List[str]
+        :param url: Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>
+        :type url: List[str]
+        :param metadata: Optional metadata to attach to the datapoint.
+        :type metadata: List[DatasetDatasetIdDatapointsPostRequestMetadataInner]
+        :param sort_index: The index will be used to keep the datapoints in order. Useful if upload is parallelized
+        :type sort_index: int
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -3120,8 +1338,13 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_get_serialize(
+        _param = self._dataset_dataset_id_datapoints_post_serialize(
             dataset_id=dataset_id,
+            file=file,
+            text=text,
+            url=url,
+            metadata=metadata,
+            sort_index=sort_index,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3129,7 +1352,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetByIdResult",
+            '200': "CreateDatapointResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3143,9 +1366,14 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_get_without_preload_content(
+    def dataset_dataset_id_datapoints_post_without_preload_content(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get.")],
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset")],
+        file: Annotated[Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]], Field(description="The files to upload from the local storage. Must be either images or videos.")] = None,
+        text: Annotated[Optional[List[StrictStr]], Field(description="The texts to upload. The length limit is set at 256 characters per text.")] = None,
+        url: Annotated[Optional[List[StrictStr]], Field(description="Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>")] = None,
+        metadata: Annotated[Optional[List[DatasetDatasetIdDatapointsPostRequestMetadataInner]], Field(description="Optional metadata to attach to the datapoint.")] = None,
+        sort_index: Annotated[Optional[StrictInt], Field(description="The index will be used to keep the datapoints in order. Useful if upload is parallelized")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3159,11 +1387,22 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Gets a dataset by its id.
+        """Creates a new datapoint from multiple possible sources.
 
+        Multiple files, texts, and urls can be provided. If multiple files are provided, a multi-asset datapoint will be created, meaning that all sources provided will be stored as sub-assets of the datapoint.              If multiple datapoints are desired, one should not pass in multiple files, texts, or urls, instead, one should call this endpoint multiple times with the desired file, text, or url per datapoint.              The request must be a multipart form request, where each parameter is sent as a separate part. The files, texts, and urls can be mixed and matched as needed, however, at least one of them must be provided, and one should make sure that mixing them makes sense for the dataset.
 
-        :param dataset_id: The id of the dataset to get. (required)
+        :param dataset_id: The id of the dataset (required)
         :type dataset_id: str
+        :param file: The files to upload from the local storage. Must be either images or videos.
+        :type file: List[bytearray]
+        :param text: The texts to upload. The length limit is set at 256 characters per text.
+        :type text: List[str]
+        :param url: Creates an asset from a url. The url needs to point to a publicly accessible resource. The server will download the resource and store it as an asset in the background. <remarks>     Additionally, to the urls having to be publicly accessible, they need to support HTTP HEAD requests. </remarks>
+        :type url: List[str]
+        :param metadata: Optional metadata to attach to the datapoint.
+        :type metadata: List[DatasetDatasetIdDatapointsPostRequestMetadataInner]
+        :param sort_index: The index will be used to keep the datapoints in order. Useful if upload is parallelized
+        :type sort_index: int
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -3186,8 +1425,13 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_get_serialize(
+        _param = self._dataset_dataset_id_datapoints_post_serialize(
             dataset_id=dataset_id,
+            file=file,
+            text=text,
+            url=url,
+            metadata=metadata,
+            sort_index=sort_index,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3195,7 +1439,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetByIdResult",
+            '200': "CreateDatapointResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3204,9 +1448,14 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_dataset_id_get_serialize(
+    def _dataset_dataset_id_datapoints_post_serialize(
         self,
         dataset_id,
+        file,
+        text,
+        url,
+        metadata,
+        sort_index,
         _request_auth,
         _content_type,
         _headers,
@@ -3216,6 +1465,10 @@ class DatasetApi:
         _host = None
 
         _collection_formats: Dict[str, str] = {
+            'file': 'csv',
+            'text': 'multi',
+            'url': 'multi',
+            'metadata': 'multi',
         }
 
         _path_params: Dict[str, str] = {}
@@ -3233,6 +1486,16 @@ class DatasetApi:
         # process the query parameters
         # process the header parameters
         # process the form parameters
+        if file is not None:
+            _files['file'] = file
+        if text is not None:
+            _form_params.append(('text', text))
+        if url is not None:
+            _form_params.append(('url', url))
+        if metadata is not None:
+            _form_params.append(('metadata', metadata))
+        if sort_index is not None:
+            _form_params.append(('sortIndex', sort_index))
         # process the body parameter
 
 
@@ -3246,6 +1509,19 @@ class DatasetApi:
                 ]
             )
 
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'multipart/form-data'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -3254,8 +1530,8 @@ class DatasetApi:
         ]
 
         return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/dataset/{datasetId}',
+            method='POST',
+            resource_path='/dataset/{datasetId}/datapoints',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -3272,10 +1548,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_name_patch(
+    def dataset_dataset_id_datapoints_s3_post(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to update.")],
-        update_dataset_name_model: Annotated[Optional[UpdateDatasetNameModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to upload the files to.")],
+        create_datapoints_from_s3_bucket_model: Annotated[Optional[CreateDatapointsFromS3BucketModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3288,14 +1564,15 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> None:
-        """Updates the name of a dataset.
+    ) -> UploadFromS3Result:
+        """Uploads files from an S3 bucket to a dataset.
 
+        A new datapoint will be created for each file in the bucket.
 
-        :param dataset_id: The id of the dataset to update. (required)
+        :param dataset_id: The id of the dataset to upload the files to. (required)
         :type dataset_id: str
-        :param update_dataset_name_model: The body of the request.
-        :type update_dataset_name_model: UpdateDatasetNameModel
+        :param create_datapoints_from_s3_bucket_model: The body of the request.
+        :type create_datapoints_from_s3_bucket_model: CreateDatapointsFromS3BucketModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -3318,9 +1595,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_name_patch_serialize(
+        _param = self._dataset_dataset_id_datapoints_s3_post_serialize(
             dataset_id=dataset_id,
-            update_dataset_name_model=update_dataset_name_model,
+            create_datapoints_from_s3_bucket_model=create_datapoints_from_s3_bucket_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3328,7 +1605,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
+            '200': "UploadFromS3Result",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3342,10 +1619,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_name_patch_with_http_info(
+    def dataset_dataset_id_datapoints_s3_post_with_http_info(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to update.")],
-        update_dataset_name_model: Annotated[Optional[UpdateDatasetNameModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to upload the files to.")],
+        create_datapoints_from_s3_bucket_model: Annotated[Optional[CreateDatapointsFromS3BucketModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3358,14 +1635,15 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[None]:
-        """Updates the name of a dataset.
+    ) -> ApiResponse[UploadFromS3Result]:
+        """Uploads files from an S3 bucket to a dataset.
 
+        A new datapoint will be created for each file in the bucket.
 
-        :param dataset_id: The id of the dataset to update. (required)
+        :param dataset_id: The id of the dataset to upload the files to. (required)
         :type dataset_id: str
-        :param update_dataset_name_model: The body of the request.
-        :type update_dataset_name_model: UpdateDatasetNameModel
+        :param create_datapoints_from_s3_bucket_model: The body of the request.
+        :type create_datapoints_from_s3_bucket_model: CreateDatapointsFromS3BucketModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -3388,9 +1666,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_name_patch_serialize(
+        _param = self._dataset_dataset_id_datapoints_s3_post_serialize(
             dataset_id=dataset_id,
-            update_dataset_name_model=update_dataset_name_model,
+            create_datapoints_from_s3_bucket_model=create_datapoints_from_s3_bucket_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3398,7 +1676,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
+            '200': "UploadFromS3Result",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3412,10 +1690,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_name_patch_without_preload_content(
+    def dataset_dataset_id_datapoints_s3_post_without_preload_content(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to update.")],
-        update_dataset_name_model: Annotated[Optional[UpdateDatasetNameModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to upload the files to.")],
+        create_datapoints_from_s3_bucket_model: Annotated[Optional[CreateDatapointsFromS3BucketModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3429,13 +1707,14 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Updates the name of a dataset.
+        """Uploads files from an S3 bucket to a dataset.
 
+        A new datapoint will be created for each file in the bucket.
 
-        :param dataset_id: The id of the dataset to update. (required)
+        :param dataset_id: The id of the dataset to upload the files to. (required)
         :type dataset_id: str
-        :param update_dataset_name_model: The body of the request.
-        :type update_dataset_name_model: UpdateDatasetNameModel
+        :param create_datapoints_from_s3_bucket_model: The body of the request.
+        :type create_datapoints_from_s3_bucket_model: CreateDatapointsFromS3BucketModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -3458,9 +1737,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_name_patch_serialize(
+        _param = self._dataset_dataset_id_datapoints_s3_post_serialize(
             dataset_id=dataset_id,
-            update_dataset_name_model=update_dataset_name_model,
+            create_datapoints_from_s3_bucket_model=create_datapoints_from_s3_bucket_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3468,7 +1747,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '204': None,
+            '200': "UploadFromS3Result",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3477,10 +1756,10 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_dataset_id_name_patch_serialize(
+    def _dataset_dataset_id_datapoints_s3_post_serialize(
         self,
         dataset_id,
-        update_dataset_name_model,
+        create_datapoints_from_s3_bucket_model,
         _request_auth,
         _content_type,
         _headers,
@@ -3508,10 +1787,19 @@ class DatasetApi:
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if update_dataset_name_model is not None:
-            _body_params = update_dataset_name_model
+        if create_datapoints_from_s3_bucket_model is not None:
+            _body_params = create_datapoints_from_s3_bucket_model
 
 
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'text/plain', 
+                    'application/json', 
+                    'text/json'
+                ]
+            )
 
         # set the HTTP header `Content-Type`
         if _content_type:
@@ -3536,8 +1824,8 @@ class DatasetApi:
         ]
 
         return self.api_client.param_serialize(
-            method='PATCH',
-            resource_path='/dataset/{datasetId}/name',
+            method='POST',
+            resource_path='/dataset/{datasetId}/datapoints/s3',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -3554,9 +1842,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_progress_get(
+    def dataset_dataset_id_datapoints_texts_post(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the progress of.")],
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        create_datapoint_from_text_sources_model: Annotated[Optional[CreateDatapointFromTextSourcesModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3569,12 +1858,15 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> GetDatasetProgressResult:
-        """Gets the upload progress of a dataset.
+    ) -> CreateDatapointResult:
+        """Creates a single datapoint from text sources.
 
+        If multiple text sources are uploaded, a multi asset datapoint will be created.
 
-        :param dataset_id: The id of the dataset to get the progress of. (required)
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
         :type dataset_id: str
+        :param create_datapoint_from_text_sources_model: The body of the request.
+        :type create_datapoint_from_text_sources_model: CreateDatapointFromTextSourcesModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -3597,8 +1889,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_progress_get_serialize(
+        _param = self._dataset_dataset_id_datapoints_texts_post_serialize(
             dataset_id=dataset_id,
+            create_datapoint_from_text_sources_model=create_datapoint_from_text_sources_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3606,7 +1899,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetProgressResult",
+            '200': "CreateDatapointResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3620,9 +1913,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_progress_get_with_http_info(
+    def dataset_dataset_id_datapoints_texts_post_with_http_info(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the progress of.")],
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        create_datapoint_from_text_sources_model: Annotated[Optional[CreateDatapointFromTextSourcesModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3635,12 +1929,15 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[GetDatasetProgressResult]:
-        """Gets the upload progress of a dataset.
+    ) -> ApiResponse[CreateDatapointResult]:
+        """Creates a single datapoint from text sources.
 
+        If multiple text sources are uploaded, a multi asset datapoint will be created.
 
-        :param dataset_id: The id of the dataset to get the progress of. (required)
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
         :type dataset_id: str
+        :param create_datapoint_from_text_sources_model: The body of the request.
+        :type create_datapoint_from_text_sources_model: CreateDatapointFromTextSourcesModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -3663,8 +1960,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_progress_get_serialize(
+        _param = self._dataset_dataset_id_datapoints_texts_post_serialize(
             dataset_id=dataset_id,
+            create_datapoint_from_text_sources_model=create_datapoint_from_text_sources_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3672,7 +1970,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetProgressResult",
+            '200': "CreateDatapointResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3686,9 +1984,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_dataset_id_progress_get_without_preload_content(
+    def dataset_dataset_id_datapoints_texts_post_without_preload_content(
         self,
-        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the progress of.")],
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        create_datapoint_from_text_sources_model: Annotated[Optional[CreateDatapointFromTextSourcesModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3702,11 +2001,14 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Gets the upload progress of a dataset.
+        """Creates a single datapoint from text sources.
 
+        If multiple text sources are uploaded, a multi asset datapoint will be created.
 
-        :param dataset_id: The id of the dataset to get the progress of. (required)
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
         :type dataset_id: str
+        :param create_datapoint_from_text_sources_model: The body of the request.
+        :type create_datapoint_from_text_sources_model: CreateDatapointFromTextSourcesModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -3729,8 +2031,9 @@ class DatasetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._dataset_dataset_id_progress_get_serialize(
+        _param = self._dataset_dataset_id_datapoints_texts_post_serialize(
             dataset_id=dataset_id,
+            create_datapoint_from_text_sources_model=create_datapoint_from_text_sources_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3738,7 +2041,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetProgressResult",
+            '200': "CreateDatapointResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3747,9 +2050,10 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_dataset_id_progress_get_serialize(
+    def _dataset_dataset_id_datapoints_texts_post_serialize(
         self,
         dataset_id,
+        create_datapoint_from_text_sources_model,
         _request_auth,
         _content_type,
         _headers,
@@ -3777,6 +2081,8 @@ class DatasetApi:
         # process the header parameters
         # process the form parameters
         # process the body parameter
+        if create_datapoint_from_text_sources_model is not None:
+            _body_params = create_datapoint_from_text_sources_model
 
 
         # set the HTTP header `Accept`
@@ -3789,6 +2095,21 @@ class DatasetApi:
                 ]
             )
 
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json', 
+                        'text/json', 
+                        'application/*+json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -3797,8 +2118,8 @@ class DatasetApi:
         ]
 
         return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/dataset/{datasetId}/progress',
+            method='POST',
+            resource_path='/dataset/{datasetId}/datapoints/texts',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -3815,9 +2136,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_getbyid_get(
+    def dataset_dataset_id_datapoints_urls_post(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to get.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        create_datapoint_from_urls_model: Annotated[Optional[CreateDatapointFromUrlsModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3830,12 +2152,15 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> GetDatasetByIdResult:
-        """(Deprecated) Gets a dataset by its id.
+    ) -> CreateDatapointResult:
+        """Creates a single datapoint where the assets are fetched from the specified urls.
 
+        Passing in multiple urls will create a single datapoint with a MultiAsset. Each url will be fetched and stored as a sub-asset of the MultiAsset. <para /> If any of the urls are not accessible, the request will fail.
 
-        :param id: The id of the dataset to get.
-        :type id: str
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
+        :type dataset_id: str
+        :param create_datapoint_from_urls_model: The body of the request.
+        :type create_datapoint_from_urls_model: CreateDatapointFromUrlsModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -3857,10 +2182,10 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("GET /dataset/getbyid is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_getbyid_get_serialize(
-            id=id,
+        _param = self._dataset_dataset_id_datapoints_urls_post_serialize(
+            dataset_id=dataset_id,
+            create_datapoint_from_urls_model=create_datapoint_from_urls_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3868,7 +2193,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetByIdResult",
+            '200': "CreateDatapointResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3882,9 +2207,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_getbyid_get_with_http_info(
+    def dataset_dataset_id_datapoints_urls_post_with_http_info(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to get.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        create_datapoint_from_urls_model: Annotated[Optional[CreateDatapointFromUrlsModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3897,12 +2223,15 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[GetDatasetByIdResult]:
-        """(Deprecated) Gets a dataset by its id.
+    ) -> ApiResponse[CreateDatapointResult]:
+        """Creates a single datapoint where the assets are fetched from the specified urls.
 
+        Passing in multiple urls will create a single datapoint with a MultiAsset. Each url will be fetched and stored as a sub-asset of the MultiAsset. <para /> If any of the urls are not accessible, the request will fail.
 
-        :param id: The id of the dataset to get.
-        :type id: str
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
+        :type dataset_id: str
+        :param create_datapoint_from_urls_model: The body of the request.
+        :type create_datapoint_from_urls_model: CreateDatapointFromUrlsModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -3924,10 +2253,10 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("GET /dataset/getbyid is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_getbyid_get_serialize(
-            id=id,
+        _param = self._dataset_dataset_id_datapoints_urls_post_serialize(
+            dataset_id=dataset_id,
+            create_datapoint_from_urls_model=create_datapoint_from_urls_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3935,7 +2264,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetByIdResult",
+            '200': "CreateDatapointResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3949,9 +2278,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_getbyid_get_without_preload_content(
+    def dataset_dataset_id_datapoints_urls_post_without_preload_content(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to get.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to create the datapoint in.")],
+        create_datapoint_from_urls_model: Annotated[Optional[CreateDatapointFromUrlsModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3965,11 +2295,14 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """(Deprecated) Gets a dataset by its id.
+        """Creates a single datapoint where the assets are fetched from the specified urls.
 
+        Passing in multiple urls will create a single datapoint with a MultiAsset. Each url will be fetched and stored as a sub-asset of the MultiAsset. <para /> If any of the urls are not accessible, the request will fail.
 
-        :param id: The id of the dataset to get.
-        :type id: str
+        :param dataset_id: The id of the dataset to create the datapoint in. (required)
+        :type dataset_id: str
+        :param create_datapoint_from_urls_model: The body of the request.
+        :type create_datapoint_from_urls_model: CreateDatapointFromUrlsModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -3991,10 +2324,10 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("GET /dataset/getbyid is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_getbyid_get_serialize(
-            id=id,
+        _param = self._dataset_dataset_id_datapoints_urls_post_serialize(
+            dataset_id=dataset_id,
+            create_datapoint_from_urls_model=create_datapoint_from_urls_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4002,7 +2335,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GetDatasetByIdResult",
+            '200': "CreateDatapointResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4011,9 +2344,10 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_getbyid_get_serialize(
+    def _dataset_dataset_id_datapoints_urls_post_serialize(
         self,
-        id,
+        dataset_id,
+        create_datapoint_from_urls_model,
         _request_auth,
         _content_type,
         _headers,
@@ -4035,14 +2369,14 @@ class DatasetApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if dataset_id is not None:
+            _path_params['datasetId'] = dataset_id
         # process the query parameters
-        if id is not None:
-            
-            _query_params.append(('id', id))
-            
         # process the header parameters
         # process the form parameters
         # process the body parameter
+        if create_datapoint_from_urls_model is not None:
+            _body_params = create_datapoint_from_urls_model
 
 
         # set the HTTP header `Accept`
@@ -4055,6 +2389,21 @@ class DatasetApi:
                 ]
             )
 
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json', 
+                        'text/json', 
+                        'application/*+json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -4063,8 +2412,8 @@ class DatasetApi:
         ]
 
         return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/dataset/getbyid',
+            method='POST',
+            resource_path='/dataset/{datasetId}/datapoints/urls',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -4081,10 +2430,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_import_post(
+    def dataset_dataset_id_get(
         self,
-        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to import the datapoints to.")] = None,
-        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4097,14 +2445,12 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ImportFromFileResult:
-        """(Deprecated) Imports datapoints from a csv file.
+    ) -> GetDatasetByIdResult:
+        """Gets a dataset by its id.
 
 
-        :param dataset_id: The id of the dataset to import the datapoints to.
+        :param dataset_id: The id of the dataset to get. (required)
         :type dataset_id: str
-        :param file: The csv file to import.
-        :type file: bytearray
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -4126,11 +2472,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/import is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_import_post_serialize(
+        _param = self._dataset_dataset_id_get_serialize(
             dataset_id=dataset_id,
-            file=file,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4138,7 +2482,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ImportFromFileResult",
+            '200': "GetDatasetByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4152,10 +2496,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_import_post_with_http_info(
+    def dataset_dataset_id_get_with_http_info(
         self,
-        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to import the datapoints to.")] = None,
-        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4168,14 +2511,12 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[ImportFromFileResult]:
-        """(Deprecated) Imports datapoints from a csv file.
+    ) -> ApiResponse[GetDatasetByIdResult]:
+        """Gets a dataset by its id.
 
 
-        :param dataset_id: The id of the dataset to import the datapoints to.
+        :param dataset_id: The id of the dataset to get. (required)
         :type dataset_id: str
-        :param file: The csv file to import.
-        :type file: bytearray
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -4197,11 +2538,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/import is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_import_post_serialize(
+        _param = self._dataset_dataset_id_get_serialize(
             dataset_id=dataset_id,
-            file=file,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4209,7 +2548,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ImportFromFileResult",
+            '200': "GetDatasetByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4223,10 +2562,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_import_post_without_preload_content(
+    def dataset_dataset_id_get_without_preload_content(
         self,
-        dataset_id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to import the datapoints to.")] = None,
-        file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The csv file to import.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4240,13 +2578,11 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """(Deprecated) Imports datapoints from a csv file.
+        """Gets a dataset by its id.
 
 
-        :param dataset_id: The id of the dataset to import the datapoints to.
+        :param dataset_id: The id of the dataset to get. (required)
         :type dataset_id: str
-        :param file: The csv file to import.
-        :type file: bytearray
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -4268,11 +2604,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/import is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_import_post_serialize(
+        _param = self._dataset_dataset_id_get_serialize(
             dataset_id=dataset_id,
-            file=file,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4280,7 +2614,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ImportFromFileResult",
+            '200': "GetDatasetByIdResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4289,10 +2623,9 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_import_post_serialize(
+    def _dataset_dataset_id_get_serialize(
         self,
         dataset_id,
-        file,
         _request_auth,
         _content_type,
         _headers,
@@ -4314,15 +2647,11 @@ class DatasetApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
-        # process the query parameters
         if dataset_id is not None:
-            
-            _query_params.append(('datasetId', dataset_id))
-            
+            _path_params['datasetId'] = dataset_id
+        # process the query parameters
         # process the header parameters
         # process the form parameters
-        if file is not None:
-            _files['file'] = file
         # process the body parameter
 
 
@@ -4336,19 +2665,6 @@ class DatasetApi:
                 ]
             )
 
-        # set the HTTP header `Content-Type`
-        if _content_type:
-            _header_params['Content-Type'] = _content_type
-        else:
-            _default_content_type = (
-                self.api_client.select_header_content_type(
-                    [
-                        'multipart/form-data'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -4357,8 +2673,8 @@ class DatasetApi:
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/dataset/import',
+            method='GET',
+            resource_path='/dataset/{datasetId}',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -4375,10 +2691,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_updatename_post(
+    def dataset_dataset_id_name_patch(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to update.")] = None,
-        name: Annotated[Optional[StrictStr], Field(description="The new name of the dataset.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to update.")],
+        update_dataset_name_model: Annotated[Optional[UpdateDatasetNameModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4392,13 +2708,13 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> None:
-        """(Deprecated) Updates the name of a dataset.
+        """Updates the name of a dataset.
 
 
-        :param id: The id of the dataset to update.
-        :type id: str
-        :param name: The new name of the dataset.
-        :type name: str
+        :param dataset_id: The id of the dataset to update. (required)
+        :type dataset_id: str
+        :param update_dataset_name_model: The body of the request.
+        :type update_dataset_name_model: UpdateDatasetNameModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -4420,11 +2736,10 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/updatename is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_updatename_post_serialize(
-            id=id,
-            name=name,
+        _param = self._dataset_dataset_id_name_patch_serialize(
+            dataset_id=dataset_id,
+            update_dataset_name_model=update_dataset_name_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4432,7 +2747,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4446,10 +2761,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_updatename_post_with_http_info(
+    def dataset_dataset_id_name_patch_with_http_info(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to update.")] = None,
-        name: Annotated[Optional[StrictStr], Field(description="The new name of the dataset.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to update.")],
+        update_dataset_name_model: Annotated[Optional[UpdateDatasetNameModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4463,13 +2778,13 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[None]:
-        """(Deprecated) Updates the name of a dataset.
+        """Updates the name of a dataset.
 
 
-        :param id: The id of the dataset to update.
-        :type id: str
-        :param name: The new name of the dataset.
-        :type name: str
+        :param dataset_id: The id of the dataset to update. (required)
+        :type dataset_id: str
+        :param update_dataset_name_model: The body of the request.
+        :type update_dataset_name_model: UpdateDatasetNameModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -4491,11 +2806,10 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/updatename is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_updatename_post_serialize(
-            id=id,
-            name=name,
+        _param = self._dataset_dataset_id_name_patch_serialize(
+            dataset_id=dataset_id,
+            update_dataset_name_model=update_dataset_name_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4503,7 +2817,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4517,10 +2831,10 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_updatename_post_without_preload_content(
+    def dataset_dataset_id_name_patch_without_preload_content(
         self,
-        id: Annotated[Optional[StrictStr], Field(description="The id of the dataset to update.")] = None,
-        name: Annotated[Optional[StrictStr], Field(description="The new name of the dataset.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to update.")],
+        update_dataset_name_model: Annotated[Optional[UpdateDatasetNameModel], Field(description="The body of the request.")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4534,13 +2848,13 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """(Deprecated) Updates the name of a dataset.
+        """Updates the name of a dataset.
 
 
-        :param id: The id of the dataset to update.
-        :type id: str
-        :param name: The new name of the dataset.
-        :type name: str
+        :param dataset_id: The id of the dataset to update. (required)
+        :type dataset_id: str
+        :param update_dataset_name_model: The body of the request.
+        :type update_dataset_name_model: UpdateDatasetNameModel
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -4562,11 +2876,10 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/updatename is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_updatename_post_serialize(
-            id=id,
-            name=name,
+        _param = self._dataset_dataset_id_name_patch_serialize(
+            dataset_id=dataset_id,
+            update_dataset_name_model=update_dataset_name_model,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4574,7 +2887,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': None,
+            '204': None,
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4583,10 +2896,10 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_updatename_post_serialize(
+    def _dataset_dataset_id_name_patch_serialize(
         self,
-        id,
-        name,
+        dataset_id,
+        update_dataset_name_model,
         _request_auth,
         _content_type,
         _headers,
@@ -4608,21 +2921,32 @@ class DatasetApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if dataset_id is not None:
+            _path_params['datasetId'] = dataset_id
         # process the query parameters
-        if id is not None:
-            
-            _query_params.append(('id', id))
-            
-        if name is not None:
-            
-            _query_params.append(('name', name))
-            
         # process the header parameters
         # process the form parameters
         # process the body parameter
+        if update_dataset_name_model is not None:
+            _body_params = update_dataset_name_model
 
 
 
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json', 
+                        'text/json', 
+                        'application/*+json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -4631,8 +2955,8 @@ class DatasetApi:
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/dataset/updatename',
+            method='PATCH',
+            resource_path='/dataset/{datasetId}/name',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -4649,9 +2973,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_uploadfilesfroms3_post(
+    def dataset_dataset_id_progress_get(
         self,
-        upload_files_from_s3_bucket_model: Annotated[Optional[UploadFilesFromS3BucketModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the progress of.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4664,13 +2988,12 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> UploadFromS3Result:
-        """(Deprecated) Uploads files from an S3 bucket to a dataset.
+    ) -> GetDatasetProgressResult:
+        """Gets the upload progress of a dataset.
 
-        A new datapoint will be created for each file in the bucket.
 
-        :param upload_files_from_s3_bucket_model: The body of the request.
-        :type upload_files_from_s3_bucket_model: UploadFilesFromS3BucketModel
+        :param dataset_id: The id of the dataset to get the progress of. (required)
+        :type dataset_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -4692,10 +3015,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/uploadfilesfroms3 is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_uploadfilesfroms3_post_serialize(
-            upload_files_from_s3_bucket_model=upload_files_from_s3_bucket_model,
+        _param = self._dataset_dataset_id_progress_get_serialize(
+            dataset_id=dataset_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4703,7 +3025,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadFromS3Result",
+            '200': "GetDatasetProgressResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4717,9 +3039,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_uploadfilesfroms3_post_with_http_info(
+    def dataset_dataset_id_progress_get_with_http_info(
         self,
-        upload_files_from_s3_bucket_model: Annotated[Optional[UploadFilesFromS3BucketModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the progress of.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4732,13 +3054,12 @@ class DatasetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[UploadFromS3Result]:
-        """(Deprecated) Uploads files from an S3 bucket to a dataset.
+    ) -> ApiResponse[GetDatasetProgressResult]:
+        """Gets the upload progress of a dataset.
 
-        A new datapoint will be created for each file in the bucket.
 
-        :param upload_files_from_s3_bucket_model: The body of the request.
-        :type upload_files_from_s3_bucket_model: UploadFilesFromS3BucketModel
+        :param dataset_id: The id of the dataset to get the progress of. (required)
+        :type dataset_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -4760,10 +3081,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/uploadfilesfroms3 is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_uploadfilesfroms3_post_serialize(
-            upload_files_from_s3_bucket_model=upload_files_from_s3_bucket_model,
+        _param = self._dataset_dataset_id_progress_get_serialize(
+            dataset_id=dataset_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4771,7 +3091,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadFromS3Result",
+            '200': "GetDatasetProgressResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4785,9 +3105,9 @@ class DatasetApi:
 
 
     @validate_call
-    def dataset_uploadfilesfroms3_post_without_preload_content(
+    def dataset_dataset_id_progress_get_without_preload_content(
         self,
-        upload_files_from_s3_bucket_model: Annotated[Optional[UploadFilesFromS3BucketModel], Field(description="The body of the request.")] = None,
+        dataset_id: Annotated[StrictStr, Field(description="The id of the dataset to get the progress of.")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -4801,12 +3121,11 @@ class DatasetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """(Deprecated) Uploads files from an S3 bucket to a dataset.
+        """Gets the upload progress of a dataset.
 
-        A new datapoint will be created for each file in the bucket.
 
-        :param upload_files_from_s3_bucket_model: The body of the request.
-        :type upload_files_from_s3_bucket_model: UploadFilesFromS3BucketModel
+        :param dataset_id: The id of the dataset to get the progress of. (required)
+        :type dataset_id: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -4828,10 +3147,9 @@ class DatasetApi:
         :type _host_index: int, optional
         :return: Returns the result object.
         """ # noqa: E501
-        warnings.warn("POST /dataset/uploadfilesfroms3 is deprecated.", DeprecationWarning)
 
-        _param = self._dataset_uploadfilesfroms3_post_serialize(
-            upload_files_from_s3_bucket_model=upload_files_from_s3_bucket_model,
+        _param = self._dataset_dataset_id_progress_get_serialize(
+            dataset_id=dataset_id,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -4839,7 +3157,7 @@ class DatasetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UploadFromS3Result",
+            '200': "GetDatasetProgressResult",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -4848,9 +3166,9 @@ class DatasetApi:
         return response_data.response
 
 
-    def _dataset_uploadfilesfroms3_post_serialize(
+    def _dataset_dataset_id_progress_get_serialize(
         self,
-        upload_files_from_s3_bucket_model,
+        dataset_id,
         _request_auth,
         _content_type,
         _headers,
@@ -4872,12 +3190,12 @@ class DatasetApi:
         _body_params: Optional[bytes] = None
 
         # process the path parameters
+        if dataset_id is not None:
+            _path_params['datasetId'] = dataset_id
         # process the query parameters
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if upload_files_from_s3_bucket_model is not None:
-            _body_params = upload_files_from_s3_bucket_model
 
 
         # set the HTTP header `Accept`
@@ -4890,21 +3208,6 @@ class DatasetApi:
                 ]
             )
 
-        # set the HTTP header `Content-Type`
-        if _content_type:
-            _header_params['Content-Type'] = _content_type
-        else:
-            _default_content_type = (
-                self.api_client.select_header_content_type(
-                    [
-                        'application/json', 
-                        'text/json', 
-                        'application/*+json'
-                    ]
-                )
-            )
-            if _default_content_type is not None:
-                _header_params['Content-Type'] = _default_content_type
 
         # authentication setting
         _auth_settings: List[str] = [
@@ -4913,8 +3216,8 @@ class DatasetApi:
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/dataset/uploadfilesfroms3',
+            method='GET',
+            resource_path='/dataset/{datasetId}/progress',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,