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

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

@@ -0,0 +1,55 @@
+"""Create 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 .create_document_by_file_request_body import CreateDocumentByFileRequestBody
+
+
+class CreateDocumentByFileRequest(BaseRequest):
+    """Request model for create document by file API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.request_body: CreateDocumentByFileRequestBody | None = None
+        self.file: BytesIO | None = None
+
+    @staticmethod
+    def builder() -> CreateDocumentByFileRequestBuilder:
+        return CreateDocumentByFileRequestBuilder()
+
+
+class CreateDocumentByFileRequestBuilder:
+    """Builder for CreateDocumentByFileRequest."""
+
+    def __init__(self) -> None:
+        create_document_by_file_request = CreateDocumentByFileRequest()
+        create_document_by_file_request.http_method = HttpMethod.POST
+        create_document_by_file_request.uri = "/v1/datasets/:dataset_id/document/create-by-file"
+        self._create_document_by_file_request = create_document_by_file_request
+
+    def build(self) -> CreateDocumentByFileRequest:
+        return self._create_document_by_file_request
+
+    def dataset_id(self, dataset_id: str) -> CreateDocumentByFileRequestBuilder:
+        self._create_document_by_file_request.dataset_id = dataset_id
+        self._create_document_by_file_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def request_body(self, request_body: CreateDocumentByFileRequestBody) -> CreateDocumentByFileRequestBuilder:
+        self._create_document_by_file_request.request_body = request_body
+        data_dict = request_body.model_dump(exclude_none=True, mode="json")
+        self._create_document_by_file_request.body = {"data": json.dumps(data_dict)}
+        return self
+
+    def file(self, file: BytesIO, file_name: str | None = None) -> CreateDocumentByFileRequestBuilder:
+        self._create_document_by_file_request.file = file
+        file_name = file_name or "upload"
+        self._create_document_by_file_request.files = {"file": (file_name, file)}
+        return self

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

@@ -0,0 +1,73 @@
+"""Create document by file request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .knowledge_types import DocumentForm, IndexingTechnique
+from .process_rule import ProcessRule
+from .retrieval_model import RetrievalModel
+
+
+class CreateDocumentByFileRequestBody(BaseModel):
+    """Request body model for create document by file API."""
+
+    name: str | None = None
+    original_document_id: str | None = None  # UUID for re-upload/modify
+    indexing_technique: IndexingTechnique | None = None
+    doc_form: DocumentForm | 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() -> CreateDocumentByFileRequestBodyBuilder:
+        return CreateDocumentByFileRequestBodyBuilder()
+
+
+class CreateDocumentByFileRequestBodyBuilder:
+    """Builder for CreateDocumentByFileRequestBody."""
+
+    def __init__(self) -> None:
+        self._create_document_by_file_request_body = CreateDocumentByFileRequestBody()
+
+    def build(self) -> CreateDocumentByFileRequestBody:
+        return self._create_document_by_file_request_body
+
+    def name(self, name: str) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.name = name
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.indexing_technique = indexing_technique
+        return self
+
+    def process_rule(self, process_rule: ProcessRule) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.process_rule = process_rule
+        return self
+
+    def original_document_id(self, original_document_id: str) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.original_document_id = original_document_id
+        return self
+
+    def doc_form(self, doc_form: DocumentForm) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.doc_form = doc_form
+        return self
+
+    def doc_language(self, doc_language: str) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.doc_language = doc_language
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.retrieval_model = retrieval_model
+        return self
+
+    def embedding_model(self, embedding_model: str) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.embedding_model = embedding_model
+        return self
+
+    def embedding_model_provider(self, embedding_model_provider: str) -> CreateDocumentByFileRequestBodyBuilder:
+        self._create_document_by_file_request_body.embedding_model_provider = embedding_model_provider
+        return self

dify_oapi/api/{knowledge_base/v1/model/document/create_by_file_response.py → knowledge/v1/model/create_document_by_file_response.py}

@@ -5,7 +5,7 @@ from dify_oapi.core.model.base_response import BaseResponse
 from .document_info import DocumentInfo
 
 
-class CreateByFileResponse(BaseResponse):
+class CreateDocumentByFileResponse(BaseResponse):
     """Response model for create document by file API."""
 
     document: DocumentInfo | None = None

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

@@ -0,0 +1,44 @@
+"""Create 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 .create_document_by_text_request_body import CreateDocumentByTextRequestBody
+
+
+class CreateDocumentByTextRequest(BaseRequest):
+    """Request model for create document by text API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.request_body: CreateDocumentByTextRequestBody | None = None
+
+    @staticmethod
+    def builder() -> CreateDocumentByTextRequestBuilder:
+        return CreateDocumentByTextRequestBuilder()
+
+
+class CreateDocumentByTextRequestBuilder:
+    """Builder for CreateDocumentByTextRequest."""
+
+    def __init__(self) -> None:
+        create_document_by_text_request = CreateDocumentByTextRequest()
+        create_document_by_text_request.http_method = HttpMethod.POST
+        create_document_by_text_request.uri = "/v1/datasets/:dataset_id/document/create-by-text"
+        self._create_document_by_text_request = create_document_by_text_request
+
+    def build(self) -> CreateDocumentByTextRequest:
+        return self._create_document_by_text_request
+
+    def dataset_id(self, dataset_id: str) -> CreateDocumentByTextRequestBuilder:
+        self._create_document_by_text_request.dataset_id = dataset_id
+        self._create_document_by_text_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def request_body(self, request_body: CreateDocumentByTextRequestBody) -> CreateDocumentByTextRequestBuilder:
+        self._create_document_by_text_request.request_body = request_body
+        self._create_document_by_text_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

@@ -0,0 +1,73 @@
+"""Create document by text request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .knowledge_types import DocumentForm, IndexingTechnique
+from .process_rule import ProcessRule
+from .retrieval_model import RetrievalModel
+
+
+class CreateDocumentByTextRequestBody(BaseModel):
+    """Request body model for create document by text API."""
+
+    name: str | None = None
+    text: str | None = None
+    indexing_technique: IndexingTechnique | None = None
+    doc_form: DocumentForm | 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() -> CreateDocumentByTextRequestBodyBuilder:
+        return CreateDocumentByTextRequestBodyBuilder()
+
+
+class CreateDocumentByTextRequestBodyBuilder:
+    """Builder for CreateDocumentByTextRequestBody."""
+
+    def __init__(self) -> None:
+        self._create_document_by_text_request_body = CreateDocumentByTextRequestBody()
+
+    def build(self) -> CreateDocumentByTextRequestBody:
+        return self._create_document_by_text_request_body
+
+    def name(self, name: str) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.name = name
+        return self
+
+    def text(self, text: str) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.text = text
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.indexing_technique = indexing_technique
+        return self
+
+    def process_rule(self, process_rule: ProcessRule) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.process_rule = process_rule
+        return self
+
+    def doc_form(self, doc_form: DocumentForm) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.doc_form = doc_form
+        return self
+
+    def doc_language(self, doc_language: str) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.doc_language = doc_language
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.retrieval_model = retrieval_model
+        return self
+
+    def embedding_model(self, embedding_model: str) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.embedding_model = embedding_model
+        return self
+
+    def embedding_model_provider(self, embedding_model_provider: str) -> CreateDocumentByTextRequestBodyBuilder:
+        self._create_document_by_text_request_body.embedding_model_provider = embedding_model_provider
+        return self

dify_oapi/api/{knowledge_base/v1/model/document/create_by_text_response.py → knowledge/v1/model/create_document_by_text_response.py}

@@ -1,12 +1,12 @@
-from __future__ import annotations
+"""Create document by text response model."""
 
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .document_info import DocumentInfo
 
 
-class CreateByTextResponse(BaseResponse):
-    """Response model for create document by text API"""
+class CreateDocumentByTextResponse(BaseResponse):
+    """Response model for create document by text API."""
 
     document: DocumentInfo | None = None
     batch: str | None = None

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

@@ -0,0 +1,50 @@
+"""Create segment request model."""
+
+from __future__ import annotations
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .create_segment_request_body import CreateSegmentRequestBody
+
+
+class CreateSegmentRequest(BaseRequest):
+    """Request model for create segment API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.dataset_id: str | None = None
+        self.document_id: str | None = None
+        self.request_body: CreateSegmentRequestBody | None = None
+
+    @staticmethod
+    def builder() -> CreateSegmentRequestBuilder:
+        return CreateSegmentRequestBuilder()
+
+
+class CreateSegmentRequestBuilder:
+    """Builder for CreateSegmentRequest."""
+
+    def __init__(self) -> None:
+        create_segment_request = CreateSegmentRequest()
+        create_segment_request.http_method = HttpMethod.POST
+        create_segment_request.uri = "/v1/datasets/:dataset_id/documents/:document_id/segments"
+        self._create_segment_request = create_segment_request
+
+    def build(self) -> CreateSegmentRequest:
+        return self._create_segment_request
+
+    def dataset_id(self, dataset_id: str) -> CreateSegmentRequestBuilder:
+        self._create_segment_request.dataset_id = dataset_id
+        self._create_segment_request.paths["dataset_id"] = dataset_id
+        return self
+
+    def document_id(self, document_id: str) -> CreateSegmentRequestBuilder:
+        self._create_segment_request.document_id = document_id
+        self._create_segment_request.paths["document_id"] = document_id
+        return self
+
+    def request_body(self, request_body: CreateSegmentRequestBody) -> CreateSegmentRequestBuilder:
+        self._create_segment_request.request_body = request_body
+        self._create_segment_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

@@ -0,0 +1,31 @@
+"""Create segment request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .segment_content import SegmentContent
+
+
+class CreateSegmentRequestBody(BaseModel):
+    """Request body model for create segment API."""
+
+    segments: list[SegmentContent] | None = None
+
+    @staticmethod
+    def builder() -> CreateSegmentRequestBodyBuilder:
+        return CreateSegmentRequestBodyBuilder()
+
+
+class CreateSegmentRequestBodyBuilder:
+    """Builder for CreateSegmentRequestBody."""
+
+    def __init__(self) -> None:
+        self._create_segment_request_body = CreateSegmentRequestBody()
+
+    def build(self) -> CreateSegmentRequestBody:
+        return self._create_segment_request_body
+
+    def segments(self, segments: list[SegmentContent]) -> CreateSegmentRequestBodyBuilder:
+        self._create_segment_request_body.segments = segments
+        return self

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

@@ -1,8 +1,11 @@
+"""Create segment response model."""
+
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .segment_info import SegmentInfo
 
 
-class CreateResponse(BaseResponse):
+class CreateSegmentResponse(BaseResponse):
+    """Response model for create segment API."""
+
     data: list[SegmentInfo] | None = None
-    doc_form: str | None = None

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

@@ -0,0 +1,30 @@
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.model.base_request import BaseRequest
+
+from .create_tag_request_body import CreateTagRequestBody
+
+
+class CreateTagRequest(BaseRequest):
+    def __init__(self):
+        super().__init__()
+        self.request_body: CreateTagRequestBody | None = None
+
+    @staticmethod
+    def builder() -> "CreateTagRequestBuilder":
+        return CreateTagRequestBuilder()
+
+
+class CreateTagRequestBuilder:
+    def __init__(self):
+        create_tag_request = CreateTagRequest()
+        create_tag_request.http_method = HttpMethod.POST
+        create_tag_request.uri = "/v1/datasets/tags"
+        self._create_tag_request = create_tag_request
+
+    def build(self) -> CreateTagRequest:
+        return self._create_tag_request
+
+    def request_body(self, request_body: CreateTagRequestBody) -> "CreateTagRequestBuilder":
+        self._create_tag_request.request_body = request_body
+        self._create_tag_request.body = request_body.model_dump(exclude_none=True, mode="json")
+        return self

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

@@ -0,0 +1,28 @@
+from pydantic import BaseModel
+
+from .knowledge_types import TagType
+
+
+class CreateTagRequestBody(BaseModel):
+    name: str | None = None
+    type: TagType | None = None
+
+    @staticmethod
+    def builder() -> "CreateTagRequestBodyBuilder":
+        return CreateTagRequestBodyBuilder()
+
+
+class CreateTagRequestBodyBuilder:
+    def __init__(self):
+        self._create_tag_request_body = CreateTagRequestBody()
+
+    def build(self) -> CreateTagRequestBody:
+        return self._create_tag_request_body
+
+    def name(self, name: str) -> "CreateTagRequestBodyBuilder":
+        self._create_tag_request_body.name = name
+        return self
+
+    def type(self, type_value: TagType) -> "CreateTagRequestBodyBuilder":
+        self._create_tag_request_body.type = type_value
+        return self

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

@@ -0,0 +1,7 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+from .tag_info import TagInfo
+
+
+class CreateTagResponse(TagInfo, BaseResponse):
+    pass

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

@@ -0,0 +1,23 @@
+"""Data source detail models."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class UploadFileDetail(BaseModel):
+    """Upload file detail information."""
+
+    id: Optional[str] = None
+    name: Optional[str] = None
+    size: Optional[int] = None
+    extension: Optional[str] = None
+    mime_type: Optional[str] = None
+    created_by: Optional[str] = None
+    created_at: Optional[float] = None
+
+
+class DataSourceDetailDict(BaseModel):
+    """Data source detail dictionary."""
+
+    upload_file: Optional[UploadFileDetail] = None

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

@@ -0,0 +1,34 @@
+"""Data source info model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class DataSourceInfo(BaseModel):
+    """Data source info model with builder pattern."""
+
+    upload_file_id: Optional[str] = None
+    original_document_id: Optional[str] = None
+
+    @staticmethod
+    def builder() -> "DataSourceInfoBuilder":
+        return DataSourceInfoBuilder()
+
+
+class DataSourceInfoBuilder:
+    """Builder for DataSourceInfo."""
+
+    def __init__(self):
+        self._data_source_info = DataSourceInfo()
+
+    def build(self) -> DataSourceInfo:
+        return self._data_source_info
+
+    def upload_file_id(self, upload_file_id: str) -> "DataSourceInfoBuilder":
+        self._data_source_info.upload_file_id = upload_file_id
+        return self
+
+    def original_document_id(self, original_document_id: str) -> "DataSourceInfoBuilder":
+        self._data_source_info.original_document_id = original_document_id
+        return self

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

@@ -0,0 +1,123 @@
+"""Dataset information model for Knowledge Base API."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .dataset_metadata import DatasetMetadata
+from .external_knowledge_info import ExternalKnowledgeInfo
+from .external_retrieval_model import ExternalRetrievalModel
+from .knowledge_types import DataSourceType, DocumentForm, IndexingTechnique, Permission
+from .retrieval_model import RetrievalModel
+from .tag_info import TagInfo
+
+
+class DatasetInfo(BaseModel):
+    """Dataset information model with builder pattern."""
+
+    id: Optional[str] = None
+    name: Optional[str] = None
+    description: Optional[str] = None
+    provider: Optional[str] = None
+    permission: Optional[Permission] = None
+    data_source_type: Optional[DataSourceType] = None
+    indexing_technique: Optional[IndexingTechnique] = None
+    app_count: Optional[int] = None
+    document_count: Optional[int] = None
+    word_count: Optional[int] = None
+    created_by: Optional[str] = None
+    created_at: Optional[int] = None
+    updated_by: Optional[str] = None
+    updated_at: Optional[int] = None
+    embedding_model: Optional[str] = None
+    embedding_model_provider: Optional[str] = None
+    embedding_available: Optional[bool] = None
+    retrieval_model_dict: Optional[RetrievalModel] = None
+    tags: Optional[list[TagInfo]] = None
+    doc_form: Optional[DocumentForm] = None
+    external_knowledge_info: Optional[ExternalKnowledgeInfo] = None
+    external_retrieval_model: Optional[ExternalRetrievalModel] = None
+    doc_metadata: Optional[list[DatasetMetadata]] = None
+    built_in_field_enabled: Optional[bool] = None
+
+    @staticmethod
+    def builder() -> "DatasetInfoBuilder":
+        return DatasetInfoBuilder()
+
+
+class DatasetInfoBuilder:
+    """Builder for DatasetInfo."""
+
+    def __init__(self):
+        self._dataset_info = DatasetInfo()
+
+    def build(self) -> DatasetInfo:
+        return self._dataset_info
+
+    def id(self, id: str) -> "DatasetInfoBuilder":
+        self._dataset_info.id = id
+        return self
+
+    def name(self, name: str) -> "DatasetInfoBuilder":
+        self._dataset_info.name = name
+        return self
+
+    def description(self, description: str) -> "DatasetInfoBuilder":
+        self._dataset_info.description = description
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> "DatasetInfoBuilder":
+        self._dataset_info.indexing_technique = indexing_technique
+        return self
+
+    def permission(self, permission: Permission) -> "DatasetInfoBuilder":
+        self._dataset_info.permission = permission
+        return self
+
+    def data_source_type(self, data_source_type: DataSourceType) -> "DatasetInfoBuilder":
+        self._dataset_info.data_source_type = data_source_type
+        return self
+
+    def provider(self, provider: str) -> "DatasetInfoBuilder":
+        self._dataset_info.provider = provider
+        return self
+
+    def app_count(self, app_count: int) -> "DatasetInfoBuilder":
+        self._dataset_info.app_count = app_count
+        return self
+
+    def created_by(self, created_by: str) -> "DatasetInfoBuilder":
+        self._dataset_info.created_by = created_by
+        return self
+
+    def created_at(self, created_at: int) -> "DatasetInfoBuilder":
+        self._dataset_info.created_at = created_at
+        return self
+
+    def updated_by(self, updated_by: str) -> "DatasetInfoBuilder":
+        self._dataset_info.updated_by = updated_by
+        return self
+
+    def updated_at(self, updated_at: int) -> "DatasetInfoBuilder":
+        self._dataset_info.updated_at = updated_at
+        return self
+
+    def document_count(self, document_count: int) -> "DatasetInfoBuilder":
+        self._dataset_info.document_count = document_count
+        return self
+
+    def word_count(self, word_count: int) -> "DatasetInfoBuilder":
+        self._dataset_info.word_count = word_count
+        return self
+
+    def embedding_model(self, embedding_model: str) -> "DatasetInfoBuilder":
+        self._dataset_info.embedding_model = embedding_model
+        return self
+
+    def embedding_model_provider(self, embedding_model_provider: str) -> "DatasetInfoBuilder":
+        self._dataset_info.embedding_model_provider = embedding_model_provider
+        return self
+
+    def embedding_available(self, embedding_available: bool) -> "DatasetInfoBuilder":
+        self._dataset_info.embedding_available = embedding_available
+        return self

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

@@ -0,0 +1,14 @@
+"""Dataset metadata model."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class DatasetMetadata(BaseModel):
+    """Dataset metadata information."""
+
+    # Based on API response, this is typically an empty array
+    # Can be extended when actual metadata structure is known
+    key: Optional[str] = None
+    value: Optional[str] = None

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

@@ -1,3 +1,5 @@
+"""Delete child chunk request model."""
+
 from __future__ import annotations
 
 from dify_oapi.core.enum import HttpMethod
@@ -5,7 +7,9 @@ from dify_oapi.core.model.base_request import BaseRequest
 
 
 class DeleteChildChunkRequest(BaseRequest):
-    def __init__(self):
+    """Request model for delete child chunk API."""
+
+    def __init__(self) -> None:
         super().__init__()
         self.dataset_id: str | None = None
         self.document_id: str | None = None
@@ -18,7 +22,9 @@ class DeleteChildChunkRequest(BaseRequest):
 
 
 class DeleteChildChunkRequestBuilder:
-    def __init__(self):
+    """Builder for DeleteChildChunkRequest."""
+
+    def __init__(self) -> None:
         delete_child_chunk_request = DeleteChildChunkRequest()
         delete_child_chunk_request.http_method = HttpMethod.DELETE
         delete_child_chunk_request.uri = (

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

@@ -0,0 +1,9 @@
+"""Delete child chunk response model."""
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class DeleteChildChunkResponse(BaseResponse):
+    """Response model for delete child chunk API."""
+
+    result: str | None = None