opik 1.9.26__py3-none-any.whl → 1.9.41__py3-none-any.whl

opik/rest_api/datasets/raw_client.py

@@ -12,6 +12,7 @@ from ..core.pydantic_utilities import parse_obj_as
 from ..core.request_options import RequestOptions
 from ..core.serialization import convert_and_respect_annotation_metadata
 from ..errors.bad_request_error import BadRequestError
+from ..errors.conflict_error import ConflictError
 from ..errors.not_found_error import NotFoundError
 from ..types.dataset_expansion_response import DatasetExpansionResponse
 from ..types.dataset_item_filter import DatasetItemFilter
@@ -23,6 +24,9 @@ from ..types.dataset_item_write import DatasetItemWrite
 from ..types.dataset_item_write_source import DatasetItemWriteSource
 from ..types.dataset_page_public import DatasetPagePublic
 from ..types.dataset_public import DatasetPublic
+from ..types.dataset_version_diff import DatasetVersionDiff
+from ..types.dataset_version_page_public import DatasetVersionPagePublic
+from ..types.dataset_version_public import DatasetVersionPublic
 from ..types.json_node import JsonNode
 from ..types.page_columns import PageColumns
 from ..types.project_stats_public import ProjectStatsPublic
@@ -1041,6 +1045,7 @@ class RawDatasetsClient:
         *,
         page: typing.Optional[int] = None,
         size: typing.Optional[int] = None,
+        version: typing.Optional[str] = None,
         filters: typing.Optional[str] = None,
         truncate: typing.Optional[bool] = None,
         request_options: typing.Optional[RequestOptions] = None,
@@ -1056,6 +1061,8 @@ class RawDatasetsClient:
 
         size : typing.Optional[int]
 
+        version : typing.Optional[str]
+
         filters : typing.Optional[str]
 
         truncate : typing.Optional[bool]
@@ -1074,6 +1081,7 @@ class RawDatasetsClient:
             params={
                 "page": page,
                 "size": size,
+                "version": version,
                 "filters": filters,
                 "truncate": truncate,
             },
@@ -1201,54 +1209,81 @@ class RawDatasetsClient:
 
             yield stream()
 
+    def compare_dataset_versions(
+        self, id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[DatasetVersionDiff]:
+        """
+        Compare the latest committed dataset version with the current draft state. This endpoint provides insights into changes made since the last version was committed. The comparison calculates additions, modifications, deletions, and unchanged items between the latest version snapshot and current draft.
 
-class AsyncRawDatasetsClient:
-    def __init__(self, *, client_wrapper: AsyncClientWrapper):
-        self._client_wrapper = client_wrapper
+        Parameters
+        ----------
+        id : str
 
-    async def batch_update_dataset_items(
-        self,
-        *,
-        update: DatasetItemUpdate,
-        ids: typing.Optional[typing.Sequence[str]] = OMIT,
-        filters: typing.Optional[typing.Sequence[DatasetItemFilter]] = OMIT,
-        merge_tags: typing.Optional[bool] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[None]:
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[DatasetVersionDiff]
+            Diff computed successfully
         """
-        Update multiple dataset items
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/versions/diff",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    DatasetVersionDiff,
+                    parse_obj_as(
+                        type_=DatasetVersionDiff,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def create_version_tag(
+        self, version_hash: str, id: str, *, tag: str, request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[None]:
+        """
+        Add a tag to a specific dataset version for easy reference (e.g., 'baseline', 'v1.0', 'production')
 
         Parameters
         ----------
-        update : DatasetItemUpdate
-
-        ids : typing.Optional[typing.Sequence[str]]
-            List of dataset item IDs to update (max 1000). Mutually exclusive with 'filters'.
+        version_hash : str
 
-        filters : typing.Optional[typing.Sequence[DatasetItemFilter]]
+        id : str
 
-        merge_tags : typing.Optional[bool]
-            If true, merge tags with existing tags instead of replacing them. Default: false. When using 'filters', this is automatically set to true.
+        tag : str
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[None]
+        HttpResponse[None]
         """
-        _response = await self._client_wrapper.httpx_client.request(
-            "v1/private/datasets/items/batch",
-            method="PATCH",
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/versions/hash/{jsonable_encoder(version_hash)}/tags",
+            method="POST",
             json={
-                "ids": ids,
-                "filters": convert_and_respect_annotation_metadata(
-                    object_=filters, annotation=typing.Sequence[DatasetItemFilter], direction="write"
-                ),
-                "update": convert_and_respect_annotation_metadata(
-                    object_=update, annotation=DatasetItemUpdate, direction="write"
-                ),
-                "merge_tags": merge_tags,
+                "tag": tag,
             },
             headers={
                 "content-type": "application/json",
@@ -1258,7 +1293,7 @@ class AsyncRawDatasetsClient:
         )
         try:
             if 200 <= _response.status_code < 300:
-                return AsyncHttpResponse(response=_response, data=None)
+                return HttpResponse(response=_response, data=None)
             if _response.status_code == 400:
                 raise BadRequestError(
                     headers=dict(_response.headers),
@@ -1270,124 +1305,134 @@ class AsyncRawDatasetsClient:
                         ),
                     ),
                 )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 409:
+                raise ConflictError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def find_datasets(
+    def list_dataset_versions(
         self,
+        id: str,
         *,
         page: typing.Optional[int] = None,
         size: typing.Optional[int] = None,
-        with_experiments_only: typing.Optional[bool] = None,
-        with_optimizations_only: typing.Optional[bool] = None,
-        prompt_id: typing.Optional[str] = None,
-        name: typing.Optional[str] = None,
-        sorting: typing.Optional[str] = None,
-        filters: typing.Optional[str] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[DatasetPagePublic]:
+    ) -> HttpResponse[DatasetVersionPagePublic]:
         """
-        Find datasets
+        Get paginated list of versions for a dataset, ordered by creation time (newest first)
 
         Parameters
         ----------
+        id : str
+
         page : typing.Optional[int]
 
         size : typing.Optional[int]
 
-        with_experiments_only : typing.Optional[bool]
-
-        with_optimizations_only : typing.Optional[bool]
-
-        prompt_id : typing.Optional[str]
-
-        name : typing.Optional[str]
-
-        sorting : typing.Optional[str]
-
-        filters : typing.Optional[str]
-
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[DatasetPagePublic]
-            Dataset resource
+        HttpResponse[DatasetVersionPagePublic]
+            Dataset versions
         """
-        _response = await self._client_wrapper.httpx_client.request(
-            "v1/private/datasets",
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/versions",
             method="GET",
             params={
                 "page": page,
                 "size": size,
-                "with_experiments_only": with_experiments_only,
-                "with_optimizations_only": with_optimizations_only,
-                "prompt_id": prompt_id,
-                "name": name,
-                "sorting": sorting,
-                "filters": filters,
             },
             request_options=request_options,
         )
         try:
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    DatasetPagePublic,
+                    DatasetVersionPagePublic,
                     parse_obj_as(
-                        type_=DatasetPagePublic,  # type: ignore
+                        type_=DatasetVersionPagePublic,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
-                return AsyncHttpResponse(response=_response, data=_data)
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def create_dataset(
+    def create_dataset_version(
         self,
+        id: str,
         *,
-        name: str,
-        id: typing.Optional[str] = OMIT,
-        visibility: typing.Optional[DatasetWriteVisibility] = OMIT,
         tags: typing.Optional[typing.Sequence[str]] = OMIT,
-        description: typing.Optional[str] = OMIT,
+        change_description: typing.Optional[str] = OMIT,
+        metadata: typing.Optional[typing.Dict[str, str]] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[None]:
+    ) -> HttpResponse[None]:
         """
-        Create dataset
+        Create a new immutable version of the dataset by snapshotting the current state
 
         Parameters
         ----------
-        name : str
-
-        id : typing.Optional[str]
-
-        visibility : typing.Optional[DatasetWriteVisibility]
+        id : str
 
         tags : typing.Optional[typing.Sequence[str]]
+            Optional list of tags for this version
 
-        description : typing.Optional[str]
+        change_description : typing.Optional[str]
+            Optional description of changes in this version
+
+        metadata : typing.Optional[typing.Dict[str, str]]
+            Optional user-defined metadata
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[None]
+        HttpResponse[None]
         """
-        _response = await self._client_wrapper.httpx_client.request(
-            "v1/private/datasets",
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/versions",
             method="POST",
             json={
-                "id": id,
-                "name": name,
-                "visibility": visibility,
                 "tags": tags,
-                "description": description,
+                "change_description": change_description,
+                "metadata": metadata,
             },
             headers={
                 "content-type": "application/json",
@@ -1397,112 +1442,111 @@ class AsyncRawDatasetsClient:
         )
         try:
             if 200 <= _response.status_code < 300:
-                return AsyncHttpResponse(response=_response, data=None)
+                return HttpResponse(response=_response, data=None)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 409:
+                raise ConflictError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def create_or_update_dataset_items(
-        self,
-        *,
-        items: typing.Sequence[DatasetItemWrite],
-        dataset_name: typing.Optional[str] = OMIT,
-        dataset_id: typing.Optional[str] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[None]:
+    def delete_version_tag(
+        self, version_hash: str, tag: str, id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[None]:
         """
-        Create/update dataset items based on dataset item id
+        Remove a tag from a dataset version. The version itself is not deleted, only the tag reference.
 
         Parameters
         ----------
-        items : typing.Sequence[DatasetItemWrite]
+        version_hash : str
 
-        dataset_name : typing.Optional[str]
-            If null, dataset_id must be provided
+        tag : str
 
-        dataset_id : typing.Optional[str]
-            If null, dataset_name must be provided
+        id : str
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[None]
+        HttpResponse[None]
         """
-        _response = await self._client_wrapper.httpx_client.request(
-            "v1/private/datasets/items",
-            method="PUT",
-            json={
-                "dataset_name": dataset_name,
-                "dataset_id": dataset_id,
-                "items": convert_and_respect_annotation_metadata(
-                    object_=items, annotation=typing.Sequence[DatasetItemWrite], direction="write"
-                ),
-            },
-            headers={
-                "content-type": "application/json",
-            },
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/versions/{jsonable_encoder(version_hash)}/tags/{jsonable_encoder(tag)}",
+            method="DELETE",
             request_options=request_options,
-            omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
-                return AsyncHttpResponse(response=_response, data=None)
+                return HttpResponse(response=_response, data=None)
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def create_dataset_items_from_csv(
-        self,
-        *,
-        file: typing.Dict[str, typing.Optional[typing.Any]],
-        dataset_id: str,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[None]:
+    def restore_dataset_version(
+        self, id: str, *, version_ref: str, request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[DatasetVersionPublic]:
         """
-        Create dataset items from uploaded CSV file. CSV should have headers in the first row. Processing happens asynchronously in batches.
+        Restores the dataset to a previous version state. All draft items are replaced with items from the specified version. If the version is not the latest, a new version snapshot is created. If the version is the latest, only draft items are replaced (revert functionality).
 
         Parameters
         ----------
-        file : typing.Dict[str, typing.Optional[typing.Any]]
+        id : str
 
-        dataset_id : str
+        version_ref : str
+            Version hash or tag to restore from
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[None]
+        HttpResponse[DatasetVersionPublic]
+            Version restored successfully
         """
-        _response = await self._client_wrapper.httpx_client.request(
-            "v1/private/datasets/items/from-csv",
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/versions/restore",
             method="POST",
-            data={
-                "file": file,
-                "dataset_id": dataset_id,
+            json={
+                "version_ref": version_ref,
+            },
+            headers={
+                "content-type": "application/json",
             },
-            files={},
             request_options=request_options,
             omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
-                return AsyncHttpResponse(response=_response, data=None)
-            if _response.status_code == 400:
-                raise BadRequestError(
-                    headers=dict(_response.headers),
-                    body=typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
+                _data = typing.cast(
+                    DatasetVersionPublic,
+                    parse_obj_as(
+                        type_=DatasetVersionPublic,  # type: ignore
+                        object_=_response.json(),
                     ),
                 )
+                return HttpResponse(response=_response, data=_data)
             if _response.status_code == 404:
                 raise NotFoundError(
                     headers=dict(_response.headers),
@@ -1519,41 +1563,44 @@ class AsyncRawDatasetsClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def create_dataset_items_from_spans(
+    def update_dataset_version(
         self,
-        dataset_id: str,
+        version_hash: str,
+        id: str,
         *,
-        span_ids: typing.Sequence[str],
-        enrichment_options: SpanEnrichmentOptions,
+        change_description: typing.Optional[str] = OMIT,
+        tags_to_add: typing.Optional[typing.Sequence[str]] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[None]:
+    ) -> HttpResponse[DatasetVersionPublic]:
         """
-        Create dataset items from spans with enriched metadata
+        Update a dataset version's change_description and/or add new tags
 
         Parameters
         ----------
-        dataset_id : str
+        version_hash : str
 
-        span_ids : typing.Sequence[str]
-            Set of span IDs to add to the dataset
+        id : str
 
-        enrichment_options : SpanEnrichmentOptions
+        change_description : typing.Optional[str]
+            Optional description of changes in this version
+
+        tags_to_add : typing.Optional[typing.Sequence[str]]
+            Optional list of tags to add to this version
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[None]
+        HttpResponse[DatasetVersionPublic]
+            Version updated successfully
         """
-        _response = await self._client_wrapper.httpx_client.request(
-            f"v1/private/datasets/{jsonable_encoder(dataset_id)}/items/from-spans",
-            method="POST",
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/versions/hash/{jsonable_encoder(version_hash)}",
+            method="PATCH",
             json={
-                "span_ids": span_ids,
-                "enrichment_options": convert_and_respect_annotation_metadata(
-                    object_=enrichment_options, annotation=SpanEnrichmentOptions, direction="write"
-                ),
+                "change_description": change_description,
+                "tags_to_add": tags_to_add,
             },
             headers={
                 "content-type": "application/json",
@@ -1563,31 +1610,80 @@ class AsyncRawDatasetsClient:
         )
         try:
             if 200 <= _response.status_code < 300:
-                return AsyncHttpResponse(response=_response, data=None)
+                _data = typing.cast(
+                    DatasetVersionPublic,
+                    parse_obj_as(
+                        type_=DatasetVersionPublic,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 409:
+                raise ConflictError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def create_dataset_items_from_traces(
+
+class AsyncRawDatasetsClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def batch_update_dataset_items(
         self,
-        dataset_id: str,
         *,
-        trace_ids: typing.Sequence[str],
-        enrichment_options: TraceEnrichmentOptions,
+        update: DatasetItemUpdate,
+        ids: typing.Optional[typing.Sequence[str]] = OMIT,
+        filters: typing.Optional[typing.Sequence[DatasetItemFilter]] = OMIT,
+        merge_tags: typing.Optional[bool] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> AsyncHttpResponse[None]:
         """
-        Create dataset items from traces with enriched metadata
+        Update multiple dataset items
 
         Parameters
         ----------
-        dataset_id : str
+        update : DatasetItemUpdate
 
-        trace_ids : typing.Sequence[str]
-            Set of trace IDs to add to the dataset
+        ids : typing.Optional[typing.Sequence[str]]
+            List of dataset item IDs to update (max 1000). Mutually exclusive with 'filters'.
 
-        enrichment_options : TraceEnrichmentOptions
+        filters : typing.Optional[typing.Sequence[DatasetItemFilter]]
+
+        merge_tags : typing.Optional[bool]
+            If true, merge tags with existing tags instead of replacing them. Default: false. When using 'filters', this is automatically set to true.
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -1597,13 +1693,17 @@ class AsyncRawDatasetsClient:
         AsyncHttpResponse[None]
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"v1/private/datasets/{jsonable_encoder(dataset_id)}/items/from-traces",
-            method="POST",
+            "v1/private/datasets/items/batch",
+            method="PATCH",
             json={
-                "trace_ids": trace_ids,
-                "enrichment_options": convert_and_respect_annotation_metadata(
-                    object_=enrichment_options, annotation=TraceEnrichmentOptions, direction="write"
+                "ids": ids,
+                "filters": convert_and_respect_annotation_metadata(
+                    object_=filters, annotation=typing.Sequence[DatasetItemFilter], direction="write"
                 ),
+                "update": convert_and_respect_annotation_metadata(
+                    object_=update, annotation=DatasetItemUpdate, direction="write"
+                ),
+                "merge_tags": merge_tags,
             },
             headers={
                 "content-type": "application/json",
@@ -1614,40 +1714,85 @@ class AsyncRawDatasetsClient:
         try:
             if 200 <= _response.status_code < 300:
                 return AsyncHttpResponse(response=_response, data=None)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def get_dataset_by_id(
-        self, id: str, *, request_options: typing.Optional[RequestOptions] = None
-    ) -> AsyncHttpResponse[DatasetPublic]:
+    async def find_datasets(
+        self,
+        *,
+        page: typing.Optional[int] = None,
+        size: typing.Optional[int] = None,
+        with_experiments_only: typing.Optional[bool] = None,
+        with_optimizations_only: typing.Optional[bool] = None,
+        prompt_id: typing.Optional[str] = None,
+        name: typing.Optional[str] = None,
+        sorting: typing.Optional[str] = None,
+        filters: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[DatasetPagePublic]:
         """
-        Get dataset by id
+        Find datasets
 
         Parameters
         ----------
-        id : str
+        page : typing.Optional[int]
+
+        size : typing.Optional[int]
+
+        with_experiments_only : typing.Optional[bool]
+
+        with_optimizations_only : typing.Optional[bool]
+
+        prompt_id : typing.Optional[str]
+
+        name : typing.Optional[str]
+
+        sorting : typing.Optional[str]
+
+        filters : typing.Optional[str]
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[DatasetPublic]
+        AsyncHttpResponse[DatasetPagePublic]
             Dataset resource
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"v1/private/datasets/{jsonable_encoder(id)}",
+            "v1/private/datasets",
             method="GET",
+            params={
+                "page": page,
+                "size": size,
+                "with_experiments_only": with_experiments_only,
+                "with_optimizations_only": with_optimizations_only,
+                "prompt_id": prompt_id,
+                "name": name,
+                "sorting": sorting,
+                "filters": filters,
+            },
             request_options=request_options,
         )
         try:
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    DatasetPublic,
+                    DatasetPagePublic,
                     parse_obj_as(
-                        type_=DatasetPublic,  # type: ignore
+                        type_=DatasetPagePublic,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -1657,31 +1802,31 @@ class AsyncRawDatasetsClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def update_dataset(
+    async def create_dataset(
         self,
-        id: str,
         *,
         name: str,
-        description: typing.Optional[str] = OMIT,
-        visibility: typing.Optional[DatasetUpdateVisibility] = OMIT,
+        id: typing.Optional[str] = OMIT,
+        visibility: typing.Optional[DatasetWriteVisibility] = OMIT,
         tags: typing.Optional[typing.Sequence[str]] = OMIT,
+        description: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
     ) -> AsyncHttpResponse[None]:
         """
-        Update dataset by id
+        Create dataset
 
         Parameters
         ----------
-        id : str
-
         name : str
 
-        description : typing.Optional[str]
+        id : typing.Optional[str]
 
-        visibility : typing.Optional[DatasetUpdateVisibility]
+        visibility : typing.Optional[DatasetWriteVisibility]
 
         tags : typing.Optional[typing.Sequence[str]]
 
+        description : typing.Optional[str]
+
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
@@ -1690,13 +1835,14 @@ class AsyncRawDatasetsClient:
         AsyncHttpResponse[None]
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"v1/private/datasets/{jsonable_encoder(id)}",
-            method="PUT",
+            "v1/private/datasets",
+            method="POST",
             json={
+                "id": id,
                 "name": name,
-                "description": description,
                 "visibility": visibility,
                 "tags": tags,
+                "description": description,
             },
             headers={
                 "content-type": "application/json",
@@ -1712,15 +1858,26 @@ class AsyncRawDatasetsClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def delete_dataset(
-        self, id: str, *, request_options: typing.Optional[RequestOptions] = None
+    async def create_or_update_dataset_items(
+        self,
+        *,
+        items: typing.Sequence[DatasetItemWrite],
+        dataset_name: typing.Optional[str] = OMIT,
+        dataset_id: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> AsyncHttpResponse[None]:
         """
-        Delete dataset by id
+        Create/update dataset items based on dataset item id
 
         Parameters
         ----------
-        id : str
+        items : typing.Sequence[DatasetItemWrite]
+
+        dataset_name : typing.Optional[str]
+            If null, dataset_id must be provided
+
+        dataset_id : typing.Optional[str]
+            If null, dataset_name must be provided
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -1730,9 +1887,20 @@ class AsyncRawDatasetsClient:
         AsyncHttpResponse[None]
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"v1/private/datasets/{jsonable_encoder(id)}",
-            method="DELETE",
+            "v1/private/datasets/items",
+            method="PUT",
+            json={
+                "dataset_name": dataset_name,
+                "dataset_id": dataset_id,
+                "items": convert_and_respect_annotation_metadata(
+                    object_=items, annotation=typing.Sequence[DatasetItemWrite], direction="write"
+                ),
+            },
+            headers={
+                "content-type": "application/json",
+            },
             request_options=request_options,
+            omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
@@ -1742,15 +1910,21 @@ class AsyncRawDatasetsClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def delete_dataset_by_name(
-        self, *, dataset_name: str, request_options: typing.Optional[RequestOptions] = None
+    async def create_dataset_items_from_csv(
+        self,
+        *,
+        file: typing.Dict[str, typing.Optional[typing.Any]],
+        dataset_id: str,
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> AsyncHttpResponse[None]:
         """
-        Delete dataset by name
+        Create dataset items from uploaded CSV file. CSV should have headers in the first row. Processing happens asynchronously in batches.
 
         Parameters
         ----------
-        dataset_name : str
+        file : typing.Dict[str, typing.Optional[typing.Any]]
+
+        dataset_id : str
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -1760,34 +1934,65 @@ class AsyncRawDatasetsClient:
         AsyncHttpResponse[None]
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "v1/private/datasets/delete",
+            "v1/private/datasets/items/from-csv",
             method="POST",
-            json={
-                "dataset_name": dataset_name,
-            },
-            headers={
-                "content-type": "application/json",
+            data={
+                "file": file,
+                "dataset_id": dataset_id,
             },
+            files={},
             request_options=request_options,
             omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
                 return AsyncHttpResponse(response=_response, data=None)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def delete_dataset_items(
-        self, *, item_ids: typing.Sequence[str], request_options: typing.Optional[RequestOptions] = None
+    async def create_dataset_items_from_spans(
+        self,
+        dataset_id: str,
+        *,
+        span_ids: typing.Sequence[str],
+        enrichment_options: SpanEnrichmentOptions,
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> AsyncHttpResponse[None]:
         """
-        Delete dataset items
+        Create dataset items from spans with enriched metadata
 
         Parameters
         ----------
-        item_ids : typing.Sequence[str]
+        dataset_id : str
+
+        span_ids : typing.Sequence[str]
+            Set of span IDs to add to the dataset
+
+        enrichment_options : SpanEnrichmentOptions
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -1797,10 +2002,13 @@ class AsyncRawDatasetsClient:
         AsyncHttpResponse[None]
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "v1/private/datasets/items/delete",
+            f"v1/private/datasets/{jsonable_encoder(dataset_id)}/items/from-spans",
             method="POST",
             json={
-                "item_ids": item_ids,
+                "span_ids": span_ids,
+                "enrichment_options": convert_and_respect_annotation_metadata(
+                    object_=enrichment_options, annotation=SpanEnrichmentOptions, direction="write"
+                ),
             },
             headers={
                 "content-type": "application/json",
@@ -1816,15 +2024,25 @@ class AsyncRawDatasetsClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def delete_datasets_batch(
-        self, *, ids: typing.Sequence[str], request_options: typing.Optional[RequestOptions] = None
+    async def create_dataset_items_from_traces(
+        self,
+        dataset_id: str,
+        *,
+        trace_ids: typing.Sequence[str],
+        enrichment_options: TraceEnrichmentOptions,
+        request_options: typing.Optional[RequestOptions] = None,
     ) -> AsyncHttpResponse[None]:
         """
-        Delete datasets batch
+        Create dataset items from traces with enriched metadata
 
         Parameters
         ----------
-        ids : typing.Sequence[str]
+        dataset_id : str
+
+        trace_ids : typing.Sequence[str]
+            Set of trace IDs to add to the dataset
+
+        enrichment_options : TraceEnrichmentOptions
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
@@ -1834,10 +2052,13 @@ class AsyncRawDatasetsClient:
         AsyncHttpResponse[None]
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "v1/private/datasets/delete-batch",
+            f"v1/private/datasets/{jsonable_encoder(dataset_id)}/items/from-traces",
             method="POST",
             json={
-                "ids": ids,
+                "trace_ids": trace_ids,
+                "enrichment_options": convert_and_respect_annotation_metadata(
+                    object_=enrichment_options, annotation=TraceEnrichmentOptions, direction="write"
+                ),
             },
             headers={
                 "content-type": "application/json",
@@ -1853,69 +2074,35 @@ class AsyncRawDatasetsClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def expand_dataset(
-        self,
-        id: str,
-        *,
-        model: str,
-        sample_count: typing.Optional[int] = OMIT,
-        preserve_fields: typing.Optional[typing.Sequence[str]] = OMIT,
-        variation_instructions: typing.Optional[str] = OMIT,
-        custom_prompt: typing.Optional[str] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[DatasetExpansionResponse]:
+    async def get_dataset_by_id(
+        self, id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[DatasetPublic]:
         """
-        Generate synthetic dataset samples using LLM based on existing data patterns
+        Get dataset by id
 
         Parameters
         ----------
         id : str
 
-        model : str
-            The model to use for synthetic data generation
-
-        sample_count : typing.Optional[int]
-            Number of synthetic samples to generate
-
-        preserve_fields : typing.Optional[typing.Sequence[str]]
-            Fields to preserve patterns from original data
-
-        variation_instructions : typing.Optional[str]
-            Additional instructions for data variation
-
-        custom_prompt : typing.Optional[str]
-            Custom prompt to use for generation instead of auto-generated one
-
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[DatasetExpansionResponse]
-            Generated synthetic samples
+        AsyncHttpResponse[DatasetPublic]
+            Dataset resource
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"v1/private/datasets/{jsonable_encoder(id)}/expansions",
-            method="POST",
-            json={
-                "model": model,
-                "sample_count": sample_count,
-                "preserve_fields": preserve_fields,
-                "variation_instructions": variation_instructions,
-                "custom_prompt": custom_prompt,
-            },
-            headers={
-                "content-type": "application/json",
-            },
+            f"v1/private/datasets/{jsonable_encoder(id)}",
+            method="GET",
             request_options=request_options,
-            omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    DatasetExpansionResponse,
+                    DatasetPublic,
                     parse_obj_as(
-                        type_=DatasetExpansionResponse,  # type: ignore
+                        type_=DatasetPublic,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -1925,82 +2112,96 @@ class AsyncRawDatasetsClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def find_dataset_items_with_experiment_items(
+    async def update_dataset(
         self,
         id: str,
         *,
-        experiment_ids: str,
-        page: typing.Optional[int] = None,
-        size: typing.Optional[int] = None,
-        filters: typing.Optional[str] = None,
-        sorting: typing.Optional[str] = None,
-        search: typing.Optional[str] = None,
-        truncate: typing.Optional[bool] = None,
+        name: str,
+        description: typing.Optional[str] = OMIT,
+        visibility: typing.Optional[DatasetUpdateVisibility] = OMIT,
+        tags: typing.Optional[typing.Sequence[str]] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[DatasetItemPageCompare]:
+    ) -> AsyncHttpResponse[None]:
         """
-        Find dataset items with experiment items
+        Update dataset by id
 
         Parameters
         ----------
         id : str
 
-        experiment_ids : str
+        name : str
 
-        page : typing.Optional[int]
+        description : typing.Optional[str]
 
-        size : typing.Optional[int]
+        visibility : typing.Optional[DatasetUpdateVisibility]
 
-        filters : typing.Optional[str]
+        tags : typing.Optional[typing.Sequence[str]]
 
-        sorting : typing.Optional[str]
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
 
-        search : typing.Optional[str]
+        Returns
+        -------
+        AsyncHttpResponse[None]
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}",
+            method="PUT",
+            json={
+                "name": name,
+                "description": description,
+                "visibility": visibility,
+                "tags": tags,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return AsyncHttpResponse(response=_response, data=None)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-        truncate : typing.Optional[bool]
+    async def delete_dataset(
+        self, id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[None]:
+        """
+        Delete dataset by id
+
+        Parameters
+        ----------
+        id : str
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[DatasetItemPageCompare]
-            Dataset item resource
+        AsyncHttpResponse[None]
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"v1/private/datasets/{jsonable_encoder(id)}/items/experiments/items",
-            method="GET",
-            params={
-                "page": page,
-                "size": size,
-                "experiment_ids": experiment_ids,
-                "filters": filters,
-                "sorting": sorting,
-                "search": search,
-                "truncate": truncate,
-            },
+            f"v1/private/datasets/{jsonable_encoder(id)}",
+            method="DELETE",
             request_options=request_options,
         )
         try:
             if 200 <= _response.status_code < 300:
-                _data = typing.cast(
-                    DatasetItemPageCompare,
-                    parse_obj_as(
-                        type_=DatasetItemPageCompare,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-                return AsyncHttpResponse(response=_response, data=_data)
+                return AsyncHttpResponse(response=_response, data=None)
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def get_dataset_by_identifier(
+    async def delete_dataset_by_name(
         self, *, dataset_name: str, request_options: typing.Optional[RequestOptions] = None
-    ) -> AsyncHttpResponse[DatasetPublic]:
+    ) -> AsyncHttpResponse[None]:
         """
-        Get dataset by name
+        Delete dataset by name
 
         Parameters
         ----------
@@ -2011,11 +2212,10 @@ class AsyncRawDatasetsClient:
 
         Returns
         -------
-        AsyncHttpResponse[DatasetPublic]
-            Dataset resource
+        AsyncHttpResponse[None]
         """
         _response = await self._client_wrapper.httpx_client.request(
-            "v1/private/datasets/retrieve",
+            "v1/private/datasets/delete",
             method="POST",
             json={
                 "dataset_name": dataset_name,
@@ -2028,156 +2228,136 @@ class AsyncRawDatasetsClient:
         )
         try:
             if 200 <= _response.status_code < 300:
-                _data = typing.cast(
-                    DatasetPublic,
-                    parse_obj_as(
-                        type_=DatasetPublic,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-                return AsyncHttpResponse(response=_response, data=_data)
+                return AsyncHttpResponse(response=_response, data=None)
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def get_dataset_experiment_items_stats(
-        self,
-        id: str,
-        *,
-        experiment_ids: str,
-        filters: typing.Optional[str] = None,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[ProjectStatsPublic]:
+    async def delete_dataset_items(
+        self, *, item_ids: typing.Sequence[str], request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[None]:
         """
-        Get experiment items stats for dataset
+        Delete dataset items
 
         Parameters
         ----------
-        id : str
-
-        experiment_ids : str
-
-        filters : typing.Optional[str]
+        item_ids : typing.Sequence[str]
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[ProjectStatsPublic]
-            Experiment items stats resource
+        AsyncHttpResponse[None]
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"v1/private/datasets/{jsonable_encoder(id)}/items/experiments/items/stats",
-            method="GET",
-            params={
-                "experiment_ids": experiment_ids,
-                "filters": filters,
+            "v1/private/datasets/items/delete",
+            method="POST",
+            json={
+                "item_ids": item_ids,
+            },
+            headers={
+                "content-type": "application/json",
             },
             request_options=request_options,
+            omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
-                _data = typing.cast(
-                    ProjectStatsPublic,
-                    parse_obj_as(
-                        type_=ProjectStatsPublic,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-                return AsyncHttpResponse(response=_response, data=_data)
+                return AsyncHttpResponse(response=_response, data=None)
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def get_dataset_item_by_id(
-        self, item_id: str, *, request_options: typing.Optional[RequestOptions] = None
-    ) -> AsyncHttpResponse[DatasetItemPublic]:
+    async def delete_datasets_batch(
+        self, *, ids: typing.Sequence[str], request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[None]:
         """
-        Get dataset item by id
+        Delete datasets batch
 
         Parameters
         ----------
-        item_id : str
+        ids : typing.Sequence[str]
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[DatasetItemPublic]
-            Dataset item resource
+        AsyncHttpResponse[None]
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"v1/private/datasets/items/{jsonable_encoder(item_id)}",
-            method="GET",
+            "v1/private/datasets/delete-batch",
+            method="POST",
+            json={
+                "ids": ids,
+            },
+            headers={
+                "content-type": "application/json",
+            },
             request_options=request_options,
+            omit=OMIT,
         )
         try:
             if 200 <= _response.status_code < 300:
-                _data = typing.cast(
-                    DatasetItemPublic,
-                    parse_obj_as(
-                        type_=DatasetItemPublic,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-                return AsyncHttpResponse(response=_response, data=_data)
+                return AsyncHttpResponse(response=_response, data=None)
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def patch_dataset_item(
+    async def expand_dataset(
         self,
-        item_id: str,
+        id: str,
         *,
-        source: DatasetItemWriteSource,
-        data: JsonNode,
-        id: typing.Optional[str] = OMIT,
-        trace_id: typing.Optional[str] = OMIT,
-        span_id: typing.Optional[str] = OMIT,
-        tags: typing.Optional[typing.Sequence[str]] = OMIT,
+        model: str,
+        sample_count: typing.Optional[int] = OMIT,
+        preserve_fields: typing.Optional[typing.Sequence[str]] = OMIT,
+        variation_instructions: typing.Optional[str] = OMIT,
+        custom_prompt: typing.Optional[str] = OMIT,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[None]:
+    ) -> AsyncHttpResponse[DatasetExpansionResponse]:
         """
-        Partially update dataset item by id. Only provided fields will be updated.
+        Generate synthetic dataset samples using LLM based on existing data patterns
 
         Parameters
         ----------
-        item_id : str
-
-        source : DatasetItemWriteSource
+        id : str
 
-        data : JsonNode
+        model : str
+            The model to use for synthetic data generation
 
-        id : typing.Optional[str]
+        sample_count : typing.Optional[int]
+            Number of synthetic samples to generate
 
-        trace_id : typing.Optional[str]
+        preserve_fields : typing.Optional[typing.Sequence[str]]
+            Fields to preserve patterns from original data
 
-        span_id : typing.Optional[str]
+        variation_instructions : typing.Optional[str]
+            Additional instructions for data variation
 
-        tags : typing.Optional[typing.Sequence[str]]
+        custom_prompt : typing.Optional[str]
+            Custom prompt to use for generation instead of auto-generated one
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[None]
+        AsyncHttpResponse[DatasetExpansionResponse]
+            Generated synthetic samples
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"v1/private/datasets/items/{jsonable_encoder(item_id)}",
-            method="PATCH",
+            f"v1/private/datasets/{jsonable_encoder(id)}/expansions",
+            method="POST",
             json={
-                "id": id,
-                "trace_id": trace_id,
-                "span_id": span_id,
-                "source": source,
-                "data": data,
-                "tags": tags,
+                "model": model,
+                "sample_count": sample_count,
+                "preserve_fields": preserve_fields,
+                "variation_instructions": variation_instructions,
+                "custom_prompt": custom_prompt,
             },
             headers={
                 "content-type": "application/json",
@@ -2187,46 +2367,51 @@ class AsyncRawDatasetsClient:
         )
         try:
             if 200 <= _response.status_code < 300:
-                return AsyncHttpResponse(response=_response, data=None)
-            if _response.status_code == 404:
-                raise NotFoundError(
-                    headers=dict(_response.headers),
-                    body=typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
+                _data = typing.cast(
+                    DatasetExpansionResponse,
+                    parse_obj_as(
+                        type_=DatasetExpansionResponse,  # type: ignore
+                        object_=_response.json(),
                     ),
                 )
+                return AsyncHttpResponse(response=_response, data=_data)
             _response_json = _response.json()
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def get_dataset_items(
+    async def find_dataset_items_with_experiment_items(
         self,
         id: str,
         *,
+        experiment_ids: str,
         page: typing.Optional[int] = None,
         size: typing.Optional[int] = None,
         filters: typing.Optional[str] = None,
+        sorting: typing.Optional[str] = None,
+        search: typing.Optional[str] = None,
         truncate: typing.Optional[bool] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[DatasetItemPagePublic]:
+    ) -> AsyncHttpResponse[DatasetItemPageCompare]:
         """
-        Get dataset items
+        Find dataset items with experiment items
 
         Parameters
         ----------
         id : str
 
+        experiment_ids : str
+
         page : typing.Optional[int]
 
         size : typing.Optional[int]
 
         filters : typing.Optional[str]
 
+        sorting : typing.Optional[str]
+
+        search : typing.Optional[str]
+
         truncate : typing.Optional[bool]
 
         request_options : typing.Optional[RequestOptions]
@@ -2234,16 +2419,19 @@ class AsyncRawDatasetsClient:
 
         Returns
         -------
-        AsyncHttpResponse[DatasetItemPagePublic]
-            Dataset items resource
+        AsyncHttpResponse[DatasetItemPageCompare]
+            Dataset item resource
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"v1/private/datasets/{jsonable_encoder(id)}/items",
+            f"v1/private/datasets/{jsonable_encoder(id)}/items/experiments/items",
             method="GET",
             params={
                 "page": page,
                 "size": size,
+                "experiment_ids": experiment_ids,
                 "filters": filters,
+                "sorting": sorting,
+                "search": search,
                 "truncate": truncate,
             },
             request_options=request_options,
@@ -2251,9 +2439,9 @@ class AsyncRawDatasetsClient:
         try:
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    DatasetItemPagePublic,
+                    DatasetItemPageCompare,
                     parse_obj_as(
-                        type_=DatasetItemPagePublic,  # type: ignore
+                        type_=DatasetItemPageCompare,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -2263,44 +2451,93 @@ class AsyncRawDatasetsClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    async def get_dataset_items_output_columns(
+    async def get_dataset_by_identifier(
+        self, *, dataset_name: str, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[DatasetPublic]:
+        """
+        Get dataset by name
+
+        Parameters
+        ----------
+        dataset_name : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[DatasetPublic]
+            Dataset resource
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "v1/private/datasets/retrieve",
+            method="POST",
+            json={
+                "dataset_name": dataset_name,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    DatasetPublic,
+                    parse_obj_as(
+                        type_=DatasetPublic,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def get_dataset_experiment_items_stats(
         self,
         id: str,
         *,
-        experiment_ids: typing.Optional[str] = None,
+        experiment_ids: str,
+        filters: typing.Optional[str] = None,
         request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[PageColumns]:
+    ) -> AsyncHttpResponse[ProjectStatsPublic]:
         """
-        Get dataset items output columns
+        Get experiment items stats for dataset
 
         Parameters
         ----------
         id : str
 
-        experiment_ids : typing.Optional[str]
+        experiment_ids : str
+
+        filters : typing.Optional[str]
 
         request_options : typing.Optional[RequestOptions]
             Request-specific configuration.
 
         Returns
         -------
-        AsyncHttpResponse[PageColumns]
-            Dataset item output columns
+        AsyncHttpResponse[ProjectStatsPublic]
+            Experiment items stats resource
         """
         _response = await self._client_wrapper.httpx_client.request(
-            f"v1/private/datasets/{jsonable_encoder(id)}/items/experiments/items/output/columns",
+            f"v1/private/datasets/{jsonable_encoder(id)}/items/experiments/items/stats",
             method="GET",
             params={
                 "experiment_ids": experiment_ids,
+                "filters": filters,
             },
             request_options=request_options,
         )
         try:
             if 200 <= _response.status_code < 300:
                 _data = typing.cast(
-                    PageColumns,
+                    ProjectStatsPublic,
                     parse_obj_as(
-                        type_=PageColumns,  # type: ignore
+                        type_=ProjectStatsPublic,  # type: ignore
                         object_=_response.json(),
                     ),
                 )
@@ -2310,32 +2547,254 @@ class AsyncRawDatasetsClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    @contextlib.asynccontextmanager
-    async def stream_dataset_items(
-        self,
-        *,
-        dataset_name: str,
-        last_retrieved_id: typing.Optional[str] = OMIT,
-        steam_limit: typing.Optional[int] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[bytes]]]:
+    async def get_dataset_item_by_id(
+        self, item_id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[DatasetItemPublic]:
         """
-        Stream dataset items
+        Get dataset item by id
 
         Parameters
         ----------
-        dataset_name : str
-
-        last_retrieved_id : typing.Optional[str]
-
-        steam_limit : typing.Optional[int]
+        item_id : str
 
         request_options : typing.Optional[RequestOptions]
-            Request-specific configuration. You can pass in configuration such as `chunk_size`, and more to customize the request and response.
+            Request-specific configuration.
 
         Returns
         -------
-        typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[bytes]]]
+        AsyncHttpResponse[DatasetItemPublic]
+            Dataset item resource
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/items/{jsonable_encoder(item_id)}",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    DatasetItemPublic,
+                    parse_obj_as(
+                        type_=DatasetItemPublic,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def patch_dataset_item(
+        self,
+        item_id: str,
+        *,
+        source: DatasetItemWriteSource,
+        data: JsonNode,
+        id: typing.Optional[str] = OMIT,
+        trace_id: typing.Optional[str] = OMIT,
+        span_id: typing.Optional[str] = OMIT,
+        tags: typing.Optional[typing.Sequence[str]] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[None]:
+        """
+        Partially update dataset item by id. Only provided fields will be updated.
+
+        Parameters
+        ----------
+        item_id : str
+
+        source : DatasetItemWriteSource
+
+        data : JsonNode
+
+        id : typing.Optional[str]
+
+        trace_id : typing.Optional[str]
+
+        span_id : typing.Optional[str]
+
+        tags : typing.Optional[typing.Sequence[str]]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[None]
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/items/{jsonable_encoder(item_id)}",
+            method="PATCH",
+            json={
+                "id": id,
+                "trace_id": trace_id,
+                "span_id": span_id,
+                "source": source,
+                "data": data,
+                "tags": tags,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return AsyncHttpResponse(response=_response, data=None)
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def get_dataset_items(
+        self,
+        id: str,
+        *,
+        page: typing.Optional[int] = None,
+        size: typing.Optional[int] = None,
+        version: typing.Optional[str] = None,
+        filters: typing.Optional[str] = None,
+        truncate: typing.Optional[bool] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[DatasetItemPagePublic]:
+        """
+        Get dataset items
+
+        Parameters
+        ----------
+        id : str
+
+        page : typing.Optional[int]
+
+        size : typing.Optional[int]
+
+        version : typing.Optional[str]
+
+        filters : typing.Optional[str]
+
+        truncate : typing.Optional[bool]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[DatasetItemPagePublic]
+            Dataset items resource
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/items",
+            method="GET",
+            params={
+                "page": page,
+                "size": size,
+                "version": version,
+                "filters": filters,
+                "truncate": truncate,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    DatasetItemPagePublic,
+                    parse_obj_as(
+                        type_=DatasetItemPagePublic,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def get_dataset_items_output_columns(
+        self,
+        id: str,
+        *,
+        experiment_ids: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[PageColumns]:
+        """
+        Get dataset items output columns
+
+        Parameters
+        ----------
+        id : str
+
+        experiment_ids : typing.Optional[str]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[PageColumns]
+            Dataset item output columns
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/items/experiments/items/output/columns",
+            method="GET",
+            params={
+                "experiment_ids": experiment_ids,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    PageColumns,
+                    parse_obj_as(
+                        type_=PageColumns,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    @contextlib.asynccontextmanager
+    async def stream_dataset_items(
+        self,
+        *,
+        dataset_name: str,
+        last_retrieved_id: typing.Optional[str] = OMIT,
+        steam_limit: typing.Optional[int] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[bytes]]]:
+        """
+        Stream dataset items
+
+        Parameters
+        ----------
+        dataset_name : str
+
+        last_retrieved_id : typing.Optional[str]
+
+        steam_limit : typing.Optional[int]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration. You can pass in configuration such as `chunk_size`, and more to customize the request and response.
+
+        Returns
+        -------
+        typing.AsyncIterator[AsyncHttpResponse[typing.AsyncIterator[bytes]]]
             Dataset items stream or error during process
         """
         async with self._client_wrapper.httpx_client.stream(
@@ -2370,3 +2829,450 @@ class AsyncRawDatasetsClient:
                 raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
             yield await stream()
+
+    async def compare_dataset_versions(
+        self, id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[DatasetVersionDiff]:
+        """
+        Compare the latest committed dataset version with the current draft state. This endpoint provides insights into changes made since the last version was committed. The comparison calculates additions, modifications, deletions, and unchanged items between the latest version snapshot and current draft.
+
+        Parameters
+        ----------
+        id : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[DatasetVersionDiff]
+            Diff computed successfully
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/versions/diff",
+            method="GET",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    DatasetVersionDiff,
+                    parse_obj_as(
+                        type_=DatasetVersionDiff,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def create_version_tag(
+        self, version_hash: str, id: str, *, tag: str, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[None]:
+        """
+        Add a tag to a specific dataset version for easy reference (e.g., 'baseline', 'v1.0', 'production')
+
+        Parameters
+        ----------
+        version_hash : str
+
+        id : str
+
+        tag : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[None]
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/versions/hash/{jsonable_encoder(version_hash)}/tags",
+            method="POST",
+            json={
+                "tag": tag,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return AsyncHttpResponse(response=_response, data=None)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 409:
+                raise ConflictError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def list_dataset_versions(
+        self,
+        id: str,
+        *,
+        page: typing.Optional[int] = None,
+        size: typing.Optional[int] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[DatasetVersionPagePublic]:
+        """
+        Get paginated list of versions for a dataset, ordered by creation time (newest first)
+
+        Parameters
+        ----------
+        id : str
+
+        page : typing.Optional[int]
+
+        size : typing.Optional[int]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[DatasetVersionPagePublic]
+            Dataset versions
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/versions",
+            method="GET",
+            params={
+                "page": page,
+                "size": size,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    DatasetVersionPagePublic,
+                    parse_obj_as(
+                        type_=DatasetVersionPagePublic,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def create_dataset_version(
+        self,
+        id: str,
+        *,
+        tags: typing.Optional[typing.Sequence[str]] = OMIT,
+        change_description: typing.Optional[str] = OMIT,
+        metadata: typing.Optional[typing.Dict[str, str]] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[None]:
+        """
+        Create a new immutable version of the dataset by snapshotting the current state
+
+        Parameters
+        ----------
+        id : str
+
+        tags : typing.Optional[typing.Sequence[str]]
+            Optional list of tags for this version
+
+        change_description : typing.Optional[str]
+            Optional description of changes in this version
+
+        metadata : typing.Optional[typing.Dict[str, str]]
+            Optional user-defined metadata
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[None]
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/versions",
+            method="POST",
+            json={
+                "tags": tags,
+                "change_description": change_description,
+                "metadata": metadata,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return AsyncHttpResponse(response=_response, data=None)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 409:
+                raise ConflictError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def delete_version_tag(
+        self, version_hash: str, tag: str, id: str, *, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[None]:
+        """
+        Remove a tag from a dataset version. The version itself is not deleted, only the tag reference.
+
+        Parameters
+        ----------
+        version_hash : str
+
+        tag : str
+
+        id : str
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[None]
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/versions/{jsonable_encoder(version_hash)}/tags/{jsonable_encoder(tag)}",
+            method="DELETE",
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                return AsyncHttpResponse(response=_response, data=None)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def restore_dataset_version(
+        self, id: str, *, version_ref: str, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[DatasetVersionPublic]:
+        """
+        Restores the dataset to a previous version state. All draft items are replaced with items from the specified version. If the version is not the latest, a new version snapshot is created. If the version is the latest, only draft items are replaced (revert functionality).
+
+        Parameters
+        ----------
+        id : str
+
+        version_ref : str
+            Version hash or tag to restore from
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[DatasetVersionPublic]
+            Version restored successfully
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/versions/restore",
+            method="POST",
+            json={
+                "version_ref": version_ref,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    DatasetVersionPublic,
+                    parse_obj_as(
+                        type_=DatasetVersionPublic,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def update_dataset_version(
+        self,
+        version_hash: str,
+        id: str,
+        *,
+        change_description: typing.Optional[str] = OMIT,
+        tags_to_add: typing.Optional[typing.Sequence[str]] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[DatasetVersionPublic]:
+        """
+        Update a dataset version's change_description and/or add new tags
+
+        Parameters
+        ----------
+        version_hash : str
+
+        id : str
+
+        change_description : typing.Optional[str]
+            Optional description of changes in this version
+
+        tags_to_add : typing.Optional[typing.Sequence[str]]
+            Optional list of tags to add to this version
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[DatasetVersionPublic]
+            Version updated successfully
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/private/datasets/{jsonable_encoder(id)}/versions/hash/{jsonable_encoder(version_hash)}",
+            method="PATCH",
+            json={
+                "change_description": change_description,
+                "tags_to_add": tags_to_add,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    DatasetVersionPublic,
+                    parse_obj_as(
+                        type_=DatasetVersionPublic,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 404:
+                raise NotFoundError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 409:
+                raise ConflictError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)