dify-oapi2 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

dify_oapi/api/knowledge/v1/model/tag_info.py

@@ -0,0 +1,56 @@
+"""Tag information model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .knowledge_types import TagType
+
+
+class TagInfo(BaseModel):
+    """Tag information model with builder pattern."""
+
+    id: Optional[str] = None
+    name: Optional[str] = None
+    type: Optional[TagType] = None
+    binding_count: Optional[int] = None
+    created_by: Optional[str] = None
+    created_at: Optional[float] = None
+
+    @staticmethod
+    def builder() -> "TagInfoBuilder":
+        return TagInfoBuilder()
+
+
+class TagInfoBuilder:
+    """Builder for TagInfo."""
+
+    def __init__(self):
+        self._tag_info = TagInfo()
+
+    def build(self) -> TagInfo:
+        return self._tag_info
+
+    def id(self, id: str) -> "TagInfoBuilder":
+        self._tag_info.id = id
+        return self
+
+    def name(self, name: str) -> "TagInfoBuilder":
+        self._tag_info.name = name
+        return self
+
+    def type(self, type: TagType) -> "TagInfoBuilder":
+        self._tag_info.type = type
+        return self
+
+    def created_by(self, created_by: str) -> "TagInfoBuilder":
+        self._tag_info.created_by = created_by
+        return self
+
+    def created_at(self, created_at: float) -> "TagInfoBuilder":
+        self._tag_info.created_at = created_at
+        return self
+
+    def binding_count(self, binding_count: int) -> "TagInfoBuilder":
+        self._tag_info.binding_count = binding_count
+        return self

dify_oapi/api/knowledge/v1/model/unbind_tags_from_dataset_request.py

@@ -0,0 +1,30 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .unbind_tags_from_dataset_request_body import UnbindTagsFromDatasetRequestBody
+
+
+class UnbindTagsFromDatasetRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: UnbindTagsFromDatasetRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "UnbindTagsFromDatasetRequestBuilder":
+        return UnbindTagsFromDatasetRequestBuilder()
+
+
+class UnbindTagsFromDatasetRequestBuilder:
+    def __init__(self):
+        unbind_tags_from_dataset_request = UnbindTagsFromDatasetRequest()
+        unbind_tags_from_dataset_request.http_method = HttpMethod.POST
+        unbind_tags_from_dataset_request.uri = "/v1/datasets/tags/unbinding"
+        self._unbind_tags_from_dataset_request = unbind_tags_from_dataset_request
+
+    def build(self) -> UnbindTagsFromDatasetRequest:
+        return self._unbind_tags_from_dataset_request
+
+    def request_body(self, request_body: UnbindTagsFromDatasetRequestBody) -> "UnbindTagsFromDatasetRequestBuilder":
+        self._unbind_tags_from_dataset_request.request_body = request_body
+        self._unbind_tags_from_dataset_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/knowledge/v1/model/unbind_tags_from_dataset_request_body.py

@@ -0,0 +1,26 @@
+from pydantic import BaseModel
+
+
+class UnbindTagsFromDatasetRequestBody(BaseModel):
+    target_id: str | None = None
+    tag_id: str | None = None
+
+    @staticmethod
+    def builder() -> "UnbindTagsFromDatasetRequestBodyBuilder":
+        return UnbindTagsFromDatasetRequestBodyBuilder()
+
+
+class UnbindTagsFromDatasetRequestBodyBuilder:
+    def __init__(self):
+        self._unbind_tags_from_dataset_request_body = UnbindTagsFromDatasetRequestBody()
+
+    def build(self) -> UnbindTagsFromDatasetRequestBody:
+        return self._unbind_tags_from_dataset_request_body
+
+    def target_id(self, target_id: str) -> "UnbindTagsFromDatasetRequestBodyBuilder":
+        self._unbind_tags_from_dataset_request_body.target_id = target_id
+        return self
+
+    def tag_id(self, tag_id: str) -> "UnbindTagsFromDatasetRequestBodyBuilder":
+        self._unbind_tags_from_dataset_request_body.tag_id = tag_id
+        return self

dify_oapi/api/knowledge/v1/model/unbind_tags_from_dataset_response.py

@@ -0,0 +1,5 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class UnbindTagsFromDatasetResponse(BaseResponse):
+    result: str | None = None

dify_oapi/api/{knowledge_base/v1/model/segment → knowledge/v1/model}/update_child_chunk_request.py

@@ -1,3 +1,5 @@
+"""Update child chunk request model."""
+
 from __future__ import annotations
 
 from dify_oapi.core.enum import HttpMethod
@@ -7,7 +9,9 @@ from .update_child_chunk_request_body import UpdateChildChunkRequestBody
 
 
 class UpdateChildChunkRequest(BaseRequest):
-    def __init__(self):
+    """Request model for update child chunk API."""
+
+    def __init__(self) -> None:
         super().__init__()
         self.dataset_id: str | None = None
         self.document_id: str | None = None
@@ -21,7 +25,9 @@ class UpdateChildChunkRequest(BaseRequest):
 
 
 class UpdateChildChunkRequestBuilder:
-    def __init__(self):
+    """Builder for UpdateChildChunkRequest."""
+
+    def __init__(self) -> None:
         update_child_chunk_request = UpdateChildChunkRequest()
         update_child_chunk_request.http_method = HttpMethod.PATCH
         update_child_chunk_request.uri = (

dify_oapi/api/{knowledge_base/v1/model/segment → knowledge/v1/model}/update_child_chunk_request_body.py

@@ -1,10 +1,15 @@
+"""Update child chunk request body model."""
+
 from __future__ import annotations
 
 from pydantic import BaseModel
 
 
 class UpdateChildChunkRequestBody(BaseModel):
+    """Request body model for update child chunk API."""
+
     content: str | None = None
+    keywords: list[str] | None = None
 
     @staticmethod
     def builder() -> UpdateChildChunkRequestBodyBuilder:
@@ -12,7 +17,9 @@ class UpdateChildChunkRequestBody(BaseModel):
 
 
 class UpdateChildChunkRequestBodyBuilder:
-    def __init__(self):
+    """Builder for UpdateChildChunkRequestBody."""
+
+    def __init__(self) -> None:
         self._update_child_chunk_request_body = UpdateChildChunkRequestBody()
 
     def build(self) -> UpdateChildChunkRequestBody:
@@ -21,3 +28,7 @@ class UpdateChildChunkRequestBodyBuilder:
     def content(self, content: str) -> UpdateChildChunkRequestBodyBuilder:
         self._update_child_chunk_request_body.content = content
         return self
+
+    def keywords(self, keywords: list[str]) -> UpdateChildChunkRequestBodyBuilder:
+        self._update_child_chunk_request_body.keywords = keywords
+        return self

dify_oapi/api/{knowledge_base/v1/model/segment → knowledge/v1/model}/update_child_chunk_response.py

@@ -1,7 +1,11 @@
+"""Update child chunk response model."""
+
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .child_chunk_info import ChildChunkInfo
 
 
 class UpdateChildChunkResponse(BaseResponse):
+    """Response model for update child chunk API."""
+
     data: ChildChunkInfo | None = None

dify_oapi/api/knowledge/v1/model/update_dataset_request.py

@@ -0,0 +1,36 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .update_dataset_request_body import UpdateDatasetRequestBody
+
+
+class UpdateDatasetRequest(BaseRequest):
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.request_body: UpdateDatasetRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "UpdateDatasetRequestBuilder":
+        return UpdateDatasetRequestBuilder()
+
+
+class UpdateDatasetRequestBuilder:
+    def __init__(self) -> None:
+        update_dataset_request = UpdateDatasetRequest()
+        update_dataset_request.http_method = HttpMethod.PATCH
+        update_dataset_request.uri = "/v1/datasets/:dataset_id"
+        self._update_dataset_request = update_dataset_request
+
+    def build(self) -> UpdateDatasetRequest:
+        return self._update_dataset_request
+
+    def dataset_id(self, dataset_id: str) -> "UpdateDatasetRequestBuilder":
+        self._update_dataset_request.dataset_id = dataset_id
+        self._update_dataset_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def request_body(self, request_body: UpdateDatasetRequestBody) -> "UpdateDatasetRequestBuilder":
+        self._update_dataset_request.request_body = request_body
+        self._update_dataset_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/knowledge/v1/model/update_dataset_request_body.py

@@ -0,0 +1,62 @@
+from pydantic import BaseModel
+
+from .embedding_model_parameters import EmbeddingModelParameters
+from .knowledge_types import IndexingTechnique, Permission
+from .retrieval_model import RetrievalModel
+
+
+class UpdateDatasetRequestBody(BaseModel):
+    name: str | None = None
+    description: str | None = None
+    indexing_technique: IndexingTechnique | None = None
+    permission: Permission | None = None
+    provider: str | None = None
+    model: str | None = None
+    embedding_model_parameters: EmbeddingModelParameters | None = None
+    retrieval_model: RetrievalModel | None = None
+
+    @staticmethod
+    def builder() -> "UpdateDatasetRequestBodyBuilder":
+        return UpdateDatasetRequestBodyBuilder()
+
+
+class UpdateDatasetRequestBodyBuilder:
+    def __init__(self) -> None:
+        self._update_dataset_request_body = UpdateDatasetRequestBody()
+
+    def build(self) -> UpdateDatasetRequestBody:
+        return self._update_dataset_request_body
+
+    def name(self, name: str) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.name = name
+        return self
+
+    def description(self, description: str) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.description = description
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.indexing_technique = indexing_technique
+        return self
+
+    def permission(self, permission: Permission) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.permission = permission
+        return self
+
+    def provider(self, provider: str) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.provider = provider
+        return self
+
+    def model(self, model: str) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.model = model
+        return self
+
+    def embedding_model_parameters(
+        self, embedding_model_parameters: EmbeddingModelParameters
+    ) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.embedding_model_parameters = embedding_model_parameters
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> "UpdateDatasetRequestBodyBuilder":
+        self._update_dataset_request_body.retrieval_model = retrieval_model
+        return self

dify_oapi/api/knowledge/v1/model/update_dataset_response.py

@@ -0,0 +1,7 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .dataset_info import DatasetInfo
+
+
+class UpdateDatasetResponse(DatasetInfo, BaseResponse):
+    pass

dify_oapi/api/knowledge/v1/model/update_document_by_file_request.py

@@ -0,0 +1,61 @@
+"""Update document by file request model."""
+
+from __future__ import annotations
+
+import json
+from io import BytesIO
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .update_document_by_file_request_body import UpdateDocumentByFileRequestBody
+
+
+class UpdateDocumentByFileRequest(BaseRequest):
+    """Request model for update document by file API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.request_body: UpdateDocumentByFileRequestBody | None = None
+        self.file: BytesIO | None = None
+
+    @staticmethod
+    def builder() -> UpdateDocumentByFileRequestBuilder:
+        return UpdateDocumentByFileRequestBuilder()
+
+
+class UpdateDocumentByFileRequestBuilder:
+    """Builder for UpdateDocumentByFileRequest."""
+
+    def __init__(self) -> None:
+        update_document_by_file_request = UpdateDocumentByFileRequest()
+        update_document_by_file_request.http_method = HttpMethod.POST
+        update_document_by_file_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/update-by-file"
+        self._update_document_by_file_request = update_document_by_file_request
+
+    def build(self) -> UpdateDocumentByFileRequest:
+        return self._update_document_by_file_request
+
+    def dataset_id(self, dataset_id: str) -> UpdateDocumentByFileRequestBuilder:
+        self._update_document_by_file_request.dataset_id = dataset_id
+        self._update_document_by_file_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> UpdateDocumentByFileRequestBuilder:
+        self._update_document_by_file_request.document_id = document_id
+        self._update_document_by_file_request.paths["document_id"] = document_id
+        return self
+
+    def request_body(self, request_body: UpdateDocumentByFileRequestBody) -> UpdateDocumentByFileRequestBuilder:
+        self._update_document_by_file_request.request_body = request_body
+        data_dict = request_body.model_dump(exclude_none=True, mode="json")
+        self._update_document_by_file_request.body = {"data": json.dumps(data_dict)}
+        return self
+
+    def file(self, file: BytesIO, file_name: str | None = None) -> UpdateDocumentByFileRequestBuilder:
+        self._update_document_by_file_request.file = file
+        file_name = file_name or "upload"
+        self._update_document_by_file_request.files = {"file": (file_name, file)}
+        return self

dify_oapi/api/knowledge/v1/model/update_document_by_file_request_body.py

@@ -0,0 +1,68 @@
+"""Update document by file request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .knowledge_types import IndexingTechnique
+from .process_rule import ProcessRule
+from .retrieval_model import RetrievalModel
+
+
+class UpdateDocumentByFileRequestBody(BaseModel):
+    """Request body model for update document by file API."""
+
+    name: str | None = None
+    indexing_technique: IndexingTechnique | None = None
+    doc_form: str | None = None
+    doc_language: str | None = None
+    process_rule: ProcessRule | None = None
+    retrieval_model: RetrievalModel | None = None
+    embedding_model: str | None = None
+    embedding_model_provider: str | None = None
+
+    @staticmethod
+    def builder() -> UpdateDocumentByFileRequestBodyBuilder:
+        return UpdateDocumentByFileRequestBodyBuilder()
+
+
+class UpdateDocumentByFileRequestBodyBuilder:
+    """Builder for UpdateDocumentByFileRequestBody."""
+
+    def __init__(self) -> None:
+        self._update_document_by_file_request_body = UpdateDocumentByFileRequestBody()
+
+    def build(self) -> UpdateDocumentByFileRequestBody:
+        return self._update_document_by_file_request_body
+
+    def name(self, name: str) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.name = name
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.indexing_technique = indexing_technique
+        return self
+
+    def process_rule(self, process_rule: ProcessRule) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.process_rule = process_rule
+        return self
+
+    def doc_form(self, doc_form: str) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.doc_form = doc_form
+        return self
+
+    def doc_language(self, doc_language: str) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.doc_language = doc_language
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.retrieval_model = retrieval_model
+        return self
+
+    def embedding_model(self, embedding_model: str) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.embedding_model = embedding_model
+        return self
+
+    def embedding_model_provider(self, embedding_model_provider: str) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.embedding_model_provider = embedding_model_provider
+        return self

dify_oapi/api/{knowledge_base/v1/model/document/update_by_file_response.py → knowledge/v1/model/update_document_by_file_response.py}

@@ -1,12 +1,12 @@
-from __future__ import annotations
+"""Update document by file response model."""
 
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .document_info import DocumentInfo
 
 
-class UpdateByFileResponse(BaseResponse):
-    """Response model for update document by file API"""
+class UpdateDocumentByFileResponse(BaseResponse):
+    """Response model for update document by file API."""
 
     document: DocumentInfo | None = None
     batch: str | None = None

dify_oapi/api/knowledge/v1/model/update_document_by_text_request.py

@@ -0,0 +1,50 @@
+"""Update document by text request model."""
+
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .update_document_by_text_request_body import UpdateDocumentByTextRequestBody
+
+
+class UpdateDocumentByTextRequest(BaseRequest):
+    """Request model for update document by text API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.request_body: UpdateDocumentByTextRequestBody | None = None
+
+    @staticmethod
+    def builder() -> UpdateDocumentByTextRequestBuilder:
+        return UpdateDocumentByTextRequestBuilder()
+
+
+class UpdateDocumentByTextRequestBuilder:
+    """Builder for UpdateDocumentByTextRequest."""
+
+    def __init__(self) -> None:
+        update_document_by_text_request = UpdateDocumentByTextRequest()
+        update_document_by_text_request.http_method = HttpMethod.POST
+        update_document_by_text_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/update-by-text"
+        self._update_document_by_text_request = update_document_by_text_request
+
+    def build(self) -> UpdateDocumentByTextRequest:
+        return self._update_document_by_text_request
+
+    def dataset_id(self, dataset_id: str) -> UpdateDocumentByTextRequestBuilder:
+        self._update_document_by_text_request.dataset_id = dataset_id
+        self._update_document_by_text_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> UpdateDocumentByTextRequestBuilder:
+        self._update_document_by_text_request.document_id = document_id
+        self._update_document_by_text_request.paths["document_id"] = document_id
+        return self
+
+    def request_body(self, request_body: UpdateDocumentByTextRequestBody) -> UpdateDocumentByTextRequestBuilder:
+        self._update_document_by_text_request.request_body = request_body
+        self._update_document_by_text_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

dify_oapi/api/knowledge/v1/model/update_document_by_text_request_body.py

@@ -0,0 +1,73 @@
+"""Update document by text request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .knowledge_types import IndexingTechnique
+from .process_rule import ProcessRule
+from .retrieval_model import RetrievalModel
+
+
+class UpdateDocumentByTextRequestBody(BaseModel):
+    """Request body model for update document by text API."""
+
+    name: str | None = None
+    text: str | None = None
+    indexing_technique: IndexingTechnique | None = None
+    doc_form: str | None = None
+    doc_language: str | None = None
+    process_rule: ProcessRule | None = None
+    retrieval_model: RetrievalModel | None = None
+    embedding_model: str | None = None
+    embedding_model_provider: str | None = None
+
+    @staticmethod
+    def builder() -> UpdateDocumentByTextRequestBodyBuilder:
+        return UpdateDocumentByTextRequestBodyBuilder()
+
+
+class UpdateDocumentByTextRequestBodyBuilder:
+    """Builder for UpdateDocumentByTextRequestBody."""
+
+    def __init__(self) -> None:
+        self._update_document_by_text_request_body = UpdateDocumentByTextRequestBody()
+
+    def build(self) -> UpdateDocumentByTextRequestBody:
+        return self._update_document_by_text_request_body
+
+    def name(self, name: str) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.name = name
+        return self
+
+    def text(self, text: str) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.text = text
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.indexing_technique = indexing_technique
+        return self
+
+    def process_rule(self, process_rule: ProcessRule) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.process_rule = process_rule
+        return self
+
+    def doc_form(self, doc_form: str) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.doc_form = doc_form
+        return self
+
+    def doc_language(self, doc_language: str) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.doc_language = doc_language
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.retrieval_model = retrieval_model
+        return self
+
+    def embedding_model(self, embedding_model: str) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.embedding_model = embedding_model
+        return self
+
+    def embedding_model_provider(self, embedding_model_provider: str) -> UpdateDocumentByTextRequestBodyBuilder:
+        self._update_document_by_text_request_body.embedding_model_provider = embedding_model_provider
+        return self

dify_oapi/api/{knowledge_base/v1/model/document/update_by_text_response.py → knowledge/v1/model/update_document_by_text_response.py}

@@ -1,14 +1,12 @@
 """Update document by text response model."""
 
-from __future__ import annotations
-
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .document_info import DocumentInfo
 
 
-class UpdateByTextResponse(BaseResponse):
-    """Response model for updating document by text."""
+class UpdateDocumentByTextResponse(BaseResponse):
+    """Response model for update document by text API."""
 
     document: DocumentInfo | None = None
     batch: str | None = None

dify_oapi/api/knowledge/v1/model/update_document_status_request.py

@@ -0,0 +1,51 @@
+"""Update document status request model."""
+
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .knowledge_types import DocumentStatusAction
+from .update_document_status_request_body import UpdateDocumentStatusRequestBody
+
+
+class UpdateDocumentStatusRequest(BaseRequest):
+    """Request model for update document status API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.action: DocumentStatusAction | None = None
+        self.request_body: UpdateDocumentStatusRequestBody | None = None
+
+    @staticmethod
+    def builder() -> UpdateDocumentStatusRequestBuilder:
+        return UpdateDocumentStatusRequestBuilder()
+
+
+class UpdateDocumentStatusRequestBuilder:
+    """Builder for UpdateDocumentStatusRequest."""
+
+    def __init__(self) -> None:
+        update_document_status_request = UpdateDocumentStatusRequest()
+        update_document_status_request.http_method = HttpMethod.PATCH
+        update_document_status_request.uri = "/v1/datasets/:dataset_id/documents/status/:action"
+        self._update_document_status_request = update_document_status_request
+
+    def build(self) -> UpdateDocumentStatusRequest:
+        return self._update_document_status_request
+
+    def dataset_id(self, dataset_id: str) -> UpdateDocumentStatusRequestBuilder:
+        self._update_document_status_request.dataset_id = dataset_id
+        self._update_document_status_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def action(self, action: DocumentStatusAction) -> UpdateDocumentStatusRequestBuilder:
+        self._update_document_status_request.action = action
+        self._update_document_status_request.paths["action"] = action
+        return self
+
+    def request_body(self, request_body: UpdateDocumentStatusRequestBody) -> UpdateDocumentStatusRequestBuilder:
+        self._update_document_status_request.request_body = request_body
+        self._update_document_status_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self