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

dify_oapi/api/knowledge/v1/resource/document.py

@@ -0,0 +1,135 @@
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.create_document_by_file_request import CreateDocumentByFileRequest
+from ..model.create_document_by_file_response import CreateDocumentByFileResponse
+from ..model.create_document_by_text_request import CreateDocumentByTextRequest
+from ..model.create_document_by_text_response import CreateDocumentByTextResponse
+from ..model.delete_document_request import DeleteDocumentRequest
+from ..model.delete_document_response import DeleteDocumentResponse
+from ..model.get_batch_indexing_status_request import GetBatchIndexingStatusRequest
+from ..model.get_batch_indexing_status_response import GetBatchIndexingStatusResponse
+from ..model.get_document_request import GetDocumentRequest
+from ..model.get_document_response import GetDocumentResponse
+from ..model.get_upload_file_info_request import GetUploadFileInfoRequest
+from ..model.get_upload_file_info_response import GetUploadFileInfoResponse
+from ..model.list_documents_request import ListDocumentsRequest
+from ..model.list_documents_response import ListDocumentsResponse
+from ..model.update_document_by_file_request import UpdateDocumentByFileRequest
+from ..model.update_document_by_file_response import UpdateDocumentByFileResponse
+from ..model.update_document_by_text_request import UpdateDocumentByTextRequest
+from ..model.update_document_by_text_response import UpdateDocumentByTextResponse
+from ..model.update_document_status_request import UpdateDocumentStatusRequest
+from ..model.update_document_status_response import UpdateDocumentStatusResponse
+
+
+class Document:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    def create_by_file(
+        self, request: CreateDocumentByFileRequest, request_option: RequestOption
+    ) -> CreateDocumentByFileResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateDocumentByFileResponse, option=request_option)
+
+    async def acreate_by_file(
+        self, request: CreateDocumentByFileRequest, request_option: RequestOption
+    ) -> CreateDocumentByFileResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=CreateDocumentByFileResponse, option=request_option
+        )
+
+    def create_by_text(
+        self, request: CreateDocumentByTextRequest, request_option: RequestOption
+    ) -> CreateDocumentByTextResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateDocumentByTextResponse, option=request_option)
+
+    async def acreate_by_text(
+        self, request: CreateDocumentByTextRequest, request_option: RequestOption
+    ) -> CreateDocumentByTextResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=CreateDocumentByTextResponse, option=request_option
+        )
+
+    def list(self, request: ListDocumentsRequest, request_option: RequestOption) -> ListDocumentsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListDocumentsResponse, option=request_option)
+
+    async def alist(self, request: ListDocumentsRequest, request_option: RequestOption) -> ListDocumentsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=ListDocumentsResponse, option=request_option
+        )
+
+    def get(self, request: GetDocumentRequest, request_option: RequestOption) -> GetDocumentResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetDocumentResponse, option=request_option)
+
+    async def aget(self, request: GetDocumentRequest, request_option: RequestOption) -> GetDocumentResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetDocumentResponse, option=request_option)
+
+    def update_by_file(
+        self, request: UpdateDocumentByFileRequest, request_option: RequestOption
+    ) -> UpdateDocumentByFileResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateDocumentByFileResponse, option=request_option)
+
+    async def aupdate_by_file(
+        self, request: UpdateDocumentByFileRequest, request_option: RequestOption
+    ) -> UpdateDocumentByFileResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UpdateDocumentByFileResponse, option=request_option
+        )
+
+    def update_by_text(
+        self, request: UpdateDocumentByTextRequest, request_option: RequestOption
+    ) -> UpdateDocumentByTextResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateDocumentByTextResponse, option=request_option)
+
+    async def aupdate_by_text(
+        self, request: UpdateDocumentByTextRequest, request_option: RequestOption
+    ) -> UpdateDocumentByTextResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UpdateDocumentByTextResponse, option=request_option
+        )
+
+    def delete(self, request: DeleteDocumentRequest, request_option: RequestOption) -> DeleteDocumentResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteDocumentResponse, option=request_option)
+
+    async def adelete(self, request: DeleteDocumentRequest, request_option: RequestOption) -> DeleteDocumentResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=DeleteDocumentResponse, option=request_option
+        )
+
+    def file_info(self, request: GetUploadFileInfoRequest, request_option: RequestOption) -> GetUploadFileInfoResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetUploadFileInfoResponse, option=request_option)
+
+    async def afile_info(
+        self, request: GetUploadFileInfoRequest, request_option: RequestOption
+    ) -> GetUploadFileInfoResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetUploadFileInfoResponse, option=request_option
+        )
+
+    def update_status(
+        self, request: UpdateDocumentStatusRequest, request_option: RequestOption
+    ) -> UpdateDocumentStatusResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateDocumentStatusResponse, option=request_option)
+
+    async def aupdate_status(
+        self, request: UpdateDocumentStatusRequest, request_option: RequestOption
+    ) -> UpdateDocumentStatusResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UpdateDocumentStatusResponse, option=request_option
+        )
+
+    def get_batch_status(
+        self, request: GetBatchIndexingStatusRequest, request_option: RequestOption
+    ) -> GetBatchIndexingStatusResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=GetBatchIndexingStatusResponse, option=request_option
+        )
+
+    async def aget_batch_status(
+        self, request: GetBatchIndexingStatusRequest, request_option: RequestOption
+    ) -> GetBatchIndexingStatusResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetBatchIndexingStatusResponse, option=request_option
+        )

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

@@ -0,0 +1,25 @@
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.get_text_embedding_models_request import GetTextEmbeddingModelsRequest
+from ..model.get_text_embedding_models_response import GetTextEmbeddingModelsResponse
+
+
+class Model:
+    def __init__(self, config: Config):
+        self.config = config
+
+    def embedding_models(
+        self, request: GetTextEmbeddingModelsRequest, request_option: RequestOption
+    ) -> GetTextEmbeddingModelsResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=GetTextEmbeddingModelsResponse, option=request_option
+        )
+
+    async def aembedding_models(
+        self, request: GetTextEmbeddingModelsRequest, request_option: RequestOption
+    ) -> GetTextEmbeddingModelsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetTextEmbeddingModelsResponse, option=request_option
+        )

dify_oapi/api/knowledge/v1/resource/segment.py

@@ -0,0 +1,55 @@
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.create_segment_request import CreateSegmentRequest
+from ..model.create_segment_response import CreateSegmentResponse
+from ..model.delete_segment_request import DeleteSegmentRequest
+from ..model.delete_segment_response import DeleteSegmentResponse
+from ..model.get_segment_request import GetSegmentRequest
+from ..model.get_segment_response import GetSegmentResponse
+from ..model.list_segments_request import ListSegmentsRequest
+from ..model.list_segments_response import ListSegmentsResponse
+from ..model.update_segment_request import UpdateSegmentRequest
+from ..model.update_segment_response import UpdateSegmentResponse
+
+
+class Segment:
+    def __init__(self, config: Config):
+        self.config = config
+
+    def list(self, request: ListSegmentsRequest, request_option: RequestOption) -> ListSegmentsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListSegmentsResponse, option=request_option)
+
+    async def alist(self, request: ListSegmentsRequest, request_option: RequestOption) -> ListSegmentsResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=ListSegmentsResponse, option=request_option)
+
+    def create(self, request: CreateSegmentRequest, request_option: RequestOption) -> CreateSegmentResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateSegmentResponse, option=request_option)
+
+    async def acreate(self, request: CreateSegmentRequest, request_option: RequestOption) -> CreateSegmentResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=CreateSegmentResponse, option=request_option
+        )
+
+    def get(self, request: GetSegmentRequest, request_option: RequestOption) -> GetSegmentResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetSegmentResponse, option=request_option)
+
+    async def aget(self, request: GetSegmentRequest, request_option: RequestOption) -> GetSegmentResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetSegmentResponse, option=request_option)
+
+    def update(self, request: UpdateSegmentRequest, request_option: RequestOption) -> UpdateSegmentResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateSegmentResponse, option=request_option)
+
+    async def aupdate(self, request: UpdateSegmentRequest, request_option: RequestOption) -> UpdateSegmentResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UpdateSegmentResponse, option=request_option
+        )
+
+    def delete(self, request: DeleteSegmentRequest, request_option: RequestOption) -> DeleteSegmentResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteSegmentResponse, option=request_option)
+
+    async def adelete(self, request: DeleteSegmentRequest, request_option: RequestOption) -> DeleteSegmentResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=DeleteSegmentResponse, option=request_option
+        )

dify_oapi/api/knowledge/v1/resource/tag.py

@@ -0,0 +1,81 @@
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.bind_tags_to_dataset_request import BindTagsToDatasetRequest
+from ..model.bind_tags_to_dataset_response import BindTagsToDatasetResponse
+from ..model.create_tag_request import CreateTagRequest
+from ..model.create_tag_response import CreateTagResponse
+from ..model.delete_tag_request import DeleteTagRequest
+from ..model.delete_tag_response import DeleteTagResponse
+from ..model.get_dataset_tags_request import GetDatasetTagsRequest
+from ..model.get_dataset_tags_response import GetDatasetTagsResponse
+from ..model.list_tags_request import ListTagsRequest
+from ..model.list_tags_response import ListTagsResponse
+from ..model.unbind_tags_from_dataset_request import UnbindTagsFromDatasetRequest
+from ..model.unbind_tags_from_dataset_response import UnbindTagsFromDatasetResponse
+from ..model.update_tag_request import UpdateTagRequest
+from ..model.update_tag_response import UpdateTagResponse
+
+
+class Tag:
+    def __init__(self, config: Config):
+        self.config = config
+
+    def list(self, request: ListTagsRequest, request_option: RequestOption) -> ListTagsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=ListTagsResponse, option=request_option)
+
+    async def alist(self, request: ListTagsRequest, request_option: RequestOption) -> ListTagsResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=ListTagsResponse, option=request_option)
+
+    def create(self, request: CreateTagRequest, request_option: RequestOption) -> CreateTagResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateTagResponse, option=request_option)
+
+    async def acreate(self, request: CreateTagRequest, request_option: RequestOption) -> CreateTagResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=CreateTagResponse, option=request_option)
+
+    def update(self, request: UpdateTagRequest, request_option: RequestOption) -> UpdateTagResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateTagResponse, option=request_option)
+
+    async def aupdate(self, request: UpdateTagRequest, request_option: RequestOption) -> UpdateTagResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=UpdateTagResponse, option=request_option)
+
+    def delete(self, request: DeleteTagRequest, request_option: RequestOption) -> DeleteTagResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteTagResponse, option=request_option)
+
+    async def adelete(self, request: DeleteTagRequest, request_option: RequestOption) -> DeleteTagResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=DeleteTagResponse, option=request_option)
+
+    def bind(self, request: BindTagsToDatasetRequest, request_option: RequestOption) -> BindTagsToDatasetResponse:
+        return Transport.execute(self.config, request, unmarshal_as=BindTagsToDatasetResponse, option=request_option)
+
+    async def abind(
+        self, request: BindTagsToDatasetRequest, request_option: RequestOption
+    ) -> BindTagsToDatasetResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=BindTagsToDatasetResponse, option=request_option
+        )
+
+    def unbind(
+        self, request: UnbindTagsFromDatasetRequest, request_option: RequestOption
+    ) -> UnbindTagsFromDatasetResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=UnbindTagsFromDatasetResponse, option=request_option
+        )
+
+    async def aunbind(
+        self, request: UnbindTagsFromDatasetRequest, request_option: RequestOption
+    ) -> UnbindTagsFromDatasetResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UnbindTagsFromDatasetResponse, option=request_option
+        )
+
+    def get_dataset_tags(self, request: GetDatasetTagsRequest, request_option: RequestOption) -> GetDatasetTagsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetDatasetTagsResponse, option=request_option)
+
+    async def aget_dataset_tags(
+        self, request: GetDatasetTagsRequest, request_option: RequestOption
+    ) -> GetDatasetTagsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetDatasetTagsResponse, option=request_option
+        )

dify_oapi/api/knowledge/v1/version.py

@@ -0,0 +1,18 @@
+from dify_oapi.core.model.config import Config
+
+from .resource.chunk import Chunk
+from .resource.dataset import Dataset
+from .resource.document import Document
+from .resource.model import Model
+from .resource.segment import Segment
+from .resource.tag import Tag
+
+
+class V1:
+    def __init__(self, config: Config):
+        self.dataset = Dataset(config)
+        self.document = Document(config)
+        self.segment = Segment(config)
+        self.chunk = Chunk(config)
+        self.tag = Tag(config)
+        self.model = Model(config)

dify_oapi/api/workflow/v1/model/{info/app_info.py → app_info.py}

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from pydantic import BaseModel
 
-from ..workflow.workflow_types import AppMode
+from .workflow_types import AppMode
 
 
 class AppInfo(BaseModel):

dify_oapi/api/workflow/v1/model/chunk_workflow_event.py

@@ -0,0 +1,74 @@
+"""Chunk workflow event for streaming mode.
+
+This module defines the base structure for workflow streaming events
+and specific event data models.
+"""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+from .workflow_types import EventType
+
+
+class ChunkWorkflowEvent(BaseModel):
+    """Base streaming event structure for workflow execution."""
+
+    event: EventType
+    task_id: Optional[str] = None
+    workflow_run_id: Optional[str] = None
+    data: Optional[dict[str, Any]] = None
+    message_id: Optional[str] = None
+    audio: Optional[str] = None
+    created_at: Optional[int] = None
+
+    @staticmethod
+    def builder() -> "ChunkWorkflowEventBuilder":
+        """Create a new ChunkWorkflowEvent builder."""
+        return ChunkWorkflowEventBuilder()
+
+
+class ChunkWorkflowEventBuilder:
+    """Builder for ChunkWorkflowEvent."""
+
+    def __init__(self):
+        self._chunk_workflow_event = ChunkWorkflowEvent(event="ping")
+
+    def build(self) -> ChunkWorkflowEvent:
+        """Build the ChunkWorkflowEvent instance."""
+        return self._chunk_workflow_event
+
+    def event(self, event: EventType) -> "ChunkWorkflowEventBuilder":
+        """Set the event type."""
+        self._chunk_workflow_event.event = event
+        return self
+
+    def task_id(self, task_id: str) -> "ChunkWorkflowEventBuilder":
+        """Set the task ID."""
+        self._chunk_workflow_event.task_id = task_id
+        return self
+
+    def workflow_run_id(self, workflow_run_id: str) -> "ChunkWorkflowEventBuilder":
+        """Set the workflow run ID."""
+        self._chunk_workflow_event.workflow_run_id = workflow_run_id
+        return self
+
+    def data(self, data: dict[str, Any]) -> "ChunkWorkflowEventBuilder":
+        """Set the event data."""
+        self._chunk_workflow_event.data = data
+        return self
+
+    def message_id(self, message_id: str) -> "ChunkWorkflowEventBuilder":
+        """Set the message ID (for TTS events)."""
+        self._chunk_workflow_event.message_id = message_id
+        return self
+
+    def audio(self, audio: str) -> "ChunkWorkflowEventBuilder":
+        """Set the audio data (for TTS events)."""
+        self._chunk_workflow_event.audio = audio
+        return self
+
+    def created_at(self, created_at: int) -> "ChunkWorkflowEventBuilder":
+        """Set the creation timestamp."""
+        self._chunk_workflow_event.created_at = created_at
+        return self

dify_oapi/api/workflow/v1/model/file_upload_info.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class FileUploadInfo(BaseModel):
+    id: str | None = None
+    name: str | None = None
+    size: int | None = None
+    extension: str | None = None
+    mime_type: str | None = None
+    created_by: str | None = None
+    created_at: int | None = None
+
+    @staticmethod
+    def builder() -> FileUploadInfoBuilder:
+        return FileUploadInfoBuilder()
+
+
+class FileUploadInfoBuilder:
+    def __init__(self):
+        self._file_upload_info = FileUploadInfo()
+
+    def build(self) -> FileUploadInfo:
+        return self._file_upload_info
+
+    def id(self, id: str) -> FileUploadInfoBuilder:
+        self._file_upload_info.id = id
+        return self
+
+    def name(self, name: str) -> FileUploadInfoBuilder:
+        self._file_upload_info.name = name
+        return self
+
+    def size(self, size: int) -> FileUploadInfoBuilder:
+        self._file_upload_info.size = size
+        return self
+
+    def extension(self, extension: str) -> FileUploadInfoBuilder:
+        self._file_upload_info.extension = extension
+        return self
+
+    def mime_type(self, mime_type: str) -> FileUploadInfoBuilder:
+        self._file_upload_info.mime_type = mime_type
+        return self
+
+    def created_by(self, created_by: str) -> FileUploadInfoBuilder:
+        self._file_upload_info.created_by = created_by
+        return self
+
+    def created_at(self, created_at: int) -> FileUploadInfoBuilder:
+        self._file_upload_info.created_at = created_at
+        return self

dify_oapi/api/workflow/v1/model/{log/get_workflow_logs_response.py → get_workflow_logs_response.py}

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dify_oapi.core.model.base_response import BaseResponse
 
-from .log_info import LogInfo
+from .workflow_log_info import WorkflowLogInfo
 
 
 class GetWorkflowLogsResponse(BaseResponse):
@@ -10,4 +10,4 @@ class GetWorkflowLogsResponse(BaseResponse):
     limit: int | None = None
     total: int | None = None
     has_more: bool | None = None
-    data: list[LogInfo] | None = None
+    data: list[WorkflowLogInfo] | None = None

dify_oapi/api/workflow/v1/model/{workflow/get_workflow_run_detail_response.py → get_workflow_run_detail_response.py}

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
+import json
 from typing import Any
 
+from pydantic import field_validator
+
 from dify_oapi.core.model.base_response import BaseResponse
 
 from .workflow_types import WorkflowStatus
@@ -19,3 +22,18 @@ class GetWorkflowRunDetailResponse(BaseResponse):
     created_at: int | None = None
     finished_at: int | None = None
     elapsed_time: float | None = None
+
+    @field_validator("inputs", "outputs", mode="before")
+    @classmethod
+    def parse_json_fields(cls, v: Any) -> dict[str, Any] | None:
+        if v is None:
+            return None
+        if isinstance(v, str):
+            try:
+                parsed = json.loads(v)
+                return parsed if isinstance(parsed, dict) else {}
+            except (json.JSONDecodeError, TypeError):
+                return {}
+        if isinstance(v, dict):
+            return v
+        return {}

dify_oapi/api/workflow/v1/model/input_file_object_workflow.py

@@ -0,0 +1,76 @@
+"""Input file object for workflow multimodal support.
+
+This module defines the InputFileObjectWorkflow model for handling file inputs
+in workflow execution with proper validation rules.
+"""
+
+from typing import Optional
+
+from pydantic import BaseModel, model_validator
+
+from .workflow_types import FileType, TransferMethod
+
+
+class InputFileObjectWorkflow(BaseModel):
+    """File input object for workflow execution.
+
+    Supports both remote URL and local file upload methods with validation rules:
+    - When transfer_method is "remote_url": url is required, upload_file_id must be None
+    - When transfer_method is "local_file": upload_file_id is required, url must be None
+    """
+
+    type: FileType
+    transfer_method: TransferMethod
+    url: Optional[str] = None
+    upload_file_id: Optional[str] = None
+
+    @model_validator(mode="after")
+    def validate_transfer_method_fields(self):
+        """Validate that the correct fields are provided based on transfer_method."""
+        if self.transfer_method == "remote_url":
+            if not self.url:
+                raise ValueError("url is required when transfer_method is 'remote_url'")
+            if self.upload_file_id is not None:
+                raise ValueError("upload_file_id must be None when transfer_method is 'remote_url'")
+        elif self.transfer_method == "local_file":
+            if not self.upload_file_id:
+                raise ValueError("upload_file_id is required when transfer_method is 'local_file'")
+            if self.url is not None:
+                raise ValueError("url must be None when transfer_method is 'local_file'")
+        return self
+
+    @staticmethod
+    def builder() -> "InputFileObjectWorkflowBuilder":
+        """Create a new InputFileObjectWorkflow builder."""
+        return InputFileObjectWorkflowBuilder()
+
+
+class InputFileObjectWorkflowBuilder:
+    """Builder for InputFileObjectWorkflow."""
+
+    def __init__(self):
+        self._input_file_object_workflow = InputFileObjectWorkflow(type="document", transfer_method="local_file")
+
+    def build(self) -> InputFileObjectWorkflow:
+        """Build the InputFileObjectWorkflow instance."""
+        return self._input_file_object_workflow
+
+    def type(self, file_type: FileType) -> "InputFileObjectWorkflowBuilder":
+        """Set the file type."""
+        self._input_file_object_workflow.type = file_type
+        return self
+
+    def transfer_method(self, transfer_method: TransferMethod) -> "InputFileObjectWorkflowBuilder":
+        """Set the transfer method."""
+        self._input_file_object_workflow.transfer_method = transfer_method
+        return self
+
+    def url(self, url: str) -> "InputFileObjectWorkflowBuilder":
+        """Set the remote URL (for remote_url transfer method)."""
+        self._input_file_object_workflow.url = url
+        return self
+
+    def upload_file_id(self, upload_file_id: str) -> "InputFileObjectWorkflowBuilder":
+        """Set the upload file ID (for local_file transfer method)."""
+        self._input_file_object_workflow.upload_file_id = upload_file_id
+        return self