stepxmlclient 1.0.0__py3-none-any.whl

stepxmlclient/rest_client/operations/relations.py

@@ -0,0 +1,349 @@
+"""Reference (relation) operations for STEP REST API v2.
+
+In the STEP REST API, references are modeled as sub-resources on entity types:
+  GET/PUT/DELETE /products/{id}/references/{referenceTypeId}/{targetId}
+  GET/PUT/DELETE /assets/{id}/references/{referenceTypeId}/{targetId}
+  GET/PUT/DELETE /classifications/{id}/references/{referenceTypeId}/{targetId}
+  GET/PUT/DELETE /entities/{id}/references/{referenceTypeId}/{targetId}
+  GET /reference-types/{id}
+
+There is no standalone "relationship" or "cross-reference" resource in the spec.
+"""
+
+import logging
+from typing import Any, Literal, Optional
+
+from ..base import BaseOperation, handle_rest_errors
+from ..exceptions import NotFoundError, ValidationError
+from ..models.relations import (
+    RelationshipListResponse,
+    RelationshipResponse,
+    RelationshipTypeResponse,
+)
+
+# Supported entity types for reference operations
+EntityType = Literal["products", "assets", "classifications", "entities"]
+
+# Map entity type to operation-ID prefix (v1.4.0 operationIds)
+_OP_PREFIX = {
+    "products": "Product",
+    "assets": "Asset",
+    "classifications": "Classification",
+    "entities": "Entity",
+}
+
+# Map entity type to the noun used in list-reference operation IDs
+_OP_LIST_REF = {
+    "products": "ProductReference",
+    "assets": "AssetReferences",
+    "classifications": "ClassificationReferences",
+    "entities": "EntityReferences",
+}
+
+
+class RelationOperations(BaseOperation):
+    """Operations for managing references between STEP entities.
+
+    The STEP REST API models references as sub-resources attached to a source entity.
+    All methods require specifying the ``entity_type`` ('products', 'assets',
+    'classifications', or 'entities') of the *source* object.
+    """
+
+    def __init__(self, client, logger: Optional[logging.Logger] = None,
+                 context: str | None = None, workspace: str | None = None):
+        """Initialize relation operations.
+        
+        Args:
+            client: The REST API client
+            logger: Optional logger instance
+            context: STEP context ID for all API calls
+            workspace: STEP workspace ID (defaults to "Main" server-side)
+        """
+        super().__init__(client, operation_name="RelationOperations", logger=logger,
+                         context=context, workspace=workspace)
+
+    # ============================================================================
+    # Reference Operations
+    # ============================================================================
+
+    @handle_rest_errors
+    def list_references(self, entity_type: EntityType,
+                        entity_id: str,
+                        reference_type_id: str,
+                        key_id: str | None = None) -> RelationshipListResponse:
+        """List all outgoing references of a given type for a source entity.
+
+        Calls: GET /{entity_type}/{id}/references/{referenceTypeId}
+
+        Args:
+            entity_type: Source entity type ('products', 'assets', 'classifications', 'entities')
+            entity_id: Source entity ID (or alternate key value if key_id is set)
+            reference_type_id: The reference type ID to list
+            key_id: Alternate key ID for the source entity (optional)
+
+        Returns:
+            RelationshipListResponse with list of references
+        """
+        self._validate_required_params(
+            {"entity_id": entity_id, "reference_type_id": reference_type_id},
+            ["entity_id", "reference_type_id"]
+        )
+
+        list_ref = _OP_LIST_REF.get(entity_type)
+        if not list_ref:
+            raise ValidationError(f"Invalid entity_type: {entity_type!r}. Must be one of {list(_OP_LIST_REF)}")
+        # Spec operationId uses literal braces: e.g. getProductReferenceEntryByReferenceTypeIdAndTargetIdByReferenceTypeId
+        op_id = "get" + list_ref + "ByReferenceTypeId"
+
+        query_params = self._build_context_params()
+        if key_id:
+            query_params["keyId"] = key_id
+        self._log_operation(op_id, {"entity_id": entity_id, "reference_type_id": reference_type_id})
+
+        try:
+            op_func = getattr(self.client, op_id)
+            response = op_func(id=entity_id, referenceTypeId=reference_type_id, **query_params)
+        except Exception as e:
+            if "404" in str(e):
+                prefix = _OP_PREFIX.get(entity_type, "Product")
+                raise NotFoundError(entity_id, prefix)
+            raise
+
+        if isinstance(response, dict):
+            return RelationshipListResponse(**response)
+        return response
+
+    @handle_rest_errors
+    def get_reference(self, entity_type: EntityType,
+                      entity_id: str,
+                      reference_type_id: str,
+                      target_id: str,
+                      key_id: str | None = None,
+                      target_key_id: str | None = None,
+                      include_inherited_data: bool = False) -> RelationshipResponse:
+        """Get a single outgoing reference.
+
+        Calls: GET /{entity_type}/{id}/references/{referenceTypeId}/{targetId}
+
+        Args:
+            entity_type: Source entity type
+            entity_id: Source entity ID (or alternate key if key_id is set)
+            reference_type_id: The reference type ID
+            target_id: Target entity ID (or alternate key if target_key_id is set)
+            key_id: Alternate key ID for source entity (optional)
+            target_key_id: Alternate key ID for target entity (optional)
+            include_inherited_data: Whether to include inherited attribute values (default: False)
+
+        Returns:
+            RelationshipResponse with reference details
+        """
+        self._validate_required_params(
+            {"entity_id": entity_id, "reference_type_id": reference_type_id, "target_id": target_id},
+            ["entity_id", "reference_type_id", "target_id"]
+        )
+
+        prefix = _OP_PREFIX.get(entity_type, "Product")
+        op_id = f"get{prefix}ReferenceEntryByReferenceTypeIdAndTargetId"
+
+        query_params: dict[str, Any] = self._build_context_params()
+        if key_id:
+            query_params["keyId"] = key_id
+        if target_key_id:
+            query_params["targetKeyId"] = target_key_id
+        if include_inherited_data:
+            query_params["includeInheritedData"] = include_inherited_data
+        self._log_operation(op_id, {"entity_id": entity_id, "reference_type_id": reference_type_id, "target_id": target_id})
+
+        try:
+            op_func = getattr(self.client, op_id)
+            response = op_func(id=entity_id, referenceTypeId=reference_type_id, targetId=target_id, **query_params)
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(entity_id, prefix)
+            raise
+
+        if isinstance(response, dict):
+            return RelationshipResponse(**response)
+        return response
+
+    @handle_rest_errors
+    def put_reference(self, entity_type: EntityType,
+                      entity_id: str,
+                      reference_type_id: str,
+                      target_id: str,
+                      data: Optional[dict[str, Any]] = None,
+                      key_id: str | None = None,
+                      target_key_id: str | None = None,
+                      allow_overwrite: bool = False) -> RelationshipResponse:
+        """Create or replace an outgoing reference (PUT).
+
+        Calls: PUT /{entity_type}/{id}/references/{referenceTypeId}/{targetId}
+
+        Args:
+            entity_type: Source entity type
+            entity_id: Source entity ID (or alternate key if key_id is set)
+            reference_type_id: The reference type ID
+            target_id: Target entity ID (or alternate key if target_key_id is set)
+            data: Optional body with reference attribute values
+            key_id: Alternate key ID for source entity (optional)
+            target_key_id: Alternate key ID for target entity (optional)
+            allow_overwrite: Whether to allow overwriting an existing reference
+
+        Returns:
+            RelationshipResponse with created/replaced reference
+        """
+        self._validate_required_params(
+            {"entity_id": entity_id, "reference_type_id": reference_type_id, "target_id": target_id},
+            ["entity_id", "reference_type_id", "target_id"]
+        )
+
+        prefix = _OP_PREFIX.get(entity_type, "Product")
+        op_id = f"replace{prefix}ReferenceEntryByReferenceTypeIdAndTargetId"
+
+        query_params: dict[str, Any] = self._build_context_params()
+        if key_id:
+            query_params["keyId"] = key_id
+        if target_key_id:
+            query_params["targetKeyId"] = target_key_id
+        if allow_overwrite:
+            query_params["allow-overwrite"] = allow_overwrite
+        self._log_operation(op_id, {"entity_id": entity_id, "reference_type_id": reference_type_id, "target_id": target_id})
+
+        try:
+            op_func = getattr(self.client, op_id)
+            if data:
+                response = op_func(id=entity_id, referenceTypeId=reference_type_id, targetId=target_id, json=data, **query_params)
+            else:
+                response = op_func(id=entity_id, referenceTypeId=reference_type_id, targetId=target_id, **query_params)
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(entity_id, prefix)
+            if "400" in str(e):
+                raise ValidationError(str(e))
+            raise
+
+        if isinstance(response, dict):
+            return RelationshipResponse(**response)
+        return response
+
+    @handle_rest_errors
+    def delete_reference(self, entity_type: EntityType,
+                         entity_id: str,
+                         reference_type_id: str,
+                         target_id: str,
+                         key_id: str | None = None,
+                         target_key_id: str | None = None) -> bool:
+        """Delete an outgoing reference.
+
+        Calls: DELETE /{entity_type}/{id}/references/{referenceTypeId}/{targetId}
+
+        Args:
+            entity_type: Source entity type
+            entity_id: Source entity ID (or alternate key if key_id is set)
+            reference_type_id: The reference type ID
+            target_id: Target entity ID (or alternate key if target_key_id is set)
+            key_id: Alternate key ID for source entity (optional)
+            target_key_id: Alternate key ID for target entity (optional)
+
+        Returns:
+            True if deletion was successful
+        """
+        self._validate_required_params(
+            {"entity_id": entity_id, "reference_type_id": reference_type_id, "target_id": target_id},
+            ["entity_id", "reference_type_id", "target_id"]
+        )
+
+        prefix = _OP_PREFIX.get(entity_type, "Product")
+        op_id = f"delete{prefix}ReferenceEntryByReferenceTypeIdAndTargetId"
+
+        query_params = self._build_context_params()
+        if key_id:
+            query_params["keyId"] = key_id
+        if target_key_id:
+            query_params["targetKeyId"] = target_key_id
+        self._log_operation(op_id, {"entity_id": entity_id, "reference_type_id": reference_type_id, "target_id": target_id})
+
+        try:
+            op_func = getattr(self.client, op_id)
+            op_func(id=entity_id, referenceTypeId=reference_type_id, targetId=target_id, **query_params)
+            return True
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(entity_id, prefix)
+            raise
+
+    @handle_rest_errors
+    def get_incoming_references(self, entity_type: EntityType,
+                                entity_id: str,
+                                reference_type_id: str,
+                                key_id: str | None = None) -> RelationshipListResponse:
+        """List incoming references of a given type for a target entity.
+
+        Calls: GET /{entity_type}/{id}/incoming-references/{referenceTypeId}
+
+        Args:
+            entity_type: Target entity type
+            entity_id: Target entity ID (or alternate key if key_id is set)
+            reference_type_id: The reference type ID to list
+            key_id: Alternate key ID for the target entity (optional)
+
+        Returns:
+            RelationshipListResponse with list of incoming references
+        """
+        self._validate_required_params(
+            {"entity_id": entity_id, "reference_type_id": reference_type_id},
+            ["entity_id", "reference_type_id"]
+        )
+
+        prefix = _OP_PREFIX.get(entity_type, "Product")
+        op_id = f"get{prefix}IncomingReferences"
+
+        query_params = self._build_context_params()
+        if key_id:
+            query_params["keyId"] = key_id
+        self._log_operation(op_id, {"entity_id": entity_id, "reference_type_id": reference_type_id})
+
+        try:
+            op_func = getattr(self.client, op_id)
+            response = op_func(id=entity_id, referenceTypeId=reference_type_id, **query_params)
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(entity_id, prefix)
+            raise
+
+        if isinstance(response, dict):
+            return RelationshipListResponse(**response)
+        return response
+
+    # ============================================================================
+    # Reference Type Lookup
+    # ============================================================================
+
+    @handle_rest_errors
+    def get_reference_type(self, reference_type_id: str) -> RelationshipTypeResponse:
+        """Get a reference type definition by ID (GET /reference-types/{id}).
+
+        Args:
+            reference_type_id: The reference type ID
+
+        Returns:
+            RelationshipTypeResponse with reference type details
+        """
+        self._validate_required_params(
+            {"reference_type_id": reference_type_id},
+            ["reference_type_id"]
+        )
+
+        query_params = self._build_context_params()
+        self._log_operation("getReferenceType", {"reference_type_id": reference_type_id})
+
+        try:
+            response = self.client.getReferenceType(id=reference_type_id, **query_params)
+        except Exception as e:
+            if "404" in str(e):
+                raise NotFoundError(reference_type_id, "ReferenceType")
+            raise
+
+        if isinstance(response, dict):
+            return RelationshipTypeResponse(**response)
+        return response

stepxmlclient/rest_client/operations/reports.py

@@ -0,0 +1,27 @@
+"""Reporting operations for STEP REST API v2."""
+from typing import Any, Optional
+
+from ..base import BaseOperation, handle_rest_errors
+
+
+class ReportOperations(BaseOperation):
+    def __init__(self, client, logger=None, context=None, workspace=None):
+        super().__init__(client, operation_name="ReportOperations", logger=logger, context=context, workspace=workspace)
+
+    @handle_rest_errors
+    def start_historic_changes_report(self, report_id: str, data: Optional[dict[str, Any]] = None) -> dict[str, Any]:
+        self._validate_required_params({"report_id": report_id}, ["report_id"])
+        self._log_operation("startHistoricChangesReport", {"reportID": report_id})
+        kwargs: dict[str, Any] = {"id": report_id}
+        kwargs.update(self._build_context_params())
+        if data is not None:
+            kwargs["json"] = data
+        r = self.client.startHistoricChangesReport(**kwargs)
+        return r if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def clean_up_historic_changes_report(self, report_id: str) -> dict[str, Any]:
+        self._validate_required_params({"report_id": report_id}, ["report_id"])
+        self._log_operation("cleanUpHistoricChangesReport", {"reportID": report_id})
+        r = self.client.cleanUpHistoricChangesReport(id=report_id, **self._build_context_params())
+        return r if isinstance(r, dict) else r

stepxmlclient/rest_client/operations/system_information.py

@@ -0,0 +1,28 @@
+"""System information operations for STEP REST API v2.
+
+Covers the /system-information endpoint introduced in v1.4.0.
+"""
+
+import logging
+
+from ..base import BaseOperation, handle_rest_errors
+from ..models.system_information import SystemInformationResponse
+
+
+class SystemInformationOperations(BaseOperation):
+    """Operations for STEP system information."""
+
+    def __init__(self, client, logger: logging.Logger | None = None,
+                 context: str | None = None, workspace: str | None = None):
+        super().__init__(client, operation_name="SystemInformationOperations", logger=logger,
+                         context=context, workspace=workspace)
+
+    @handle_rest_errors
+    def get_system_information(self) -> SystemInformationResponse:
+        """Get system information and capabilities.
+
+        Calls: GET /system-information -> getSystemInformation
+        """
+        self._log_operation("getSystemInformation", {})
+        response = self.client.getSystemInformation(**self._build_context_params())
+        return SystemInformationResponse(**response) if isinstance(response, dict) else response

stepxmlclient/rest_client/operations/user_groups.py

@@ -0,0 +1,79 @@
+"""User group operations for STEP REST API v2."""
+
+from typing import Any
+
+from ..base import BaseOperation, handle_rest_errors
+from ..exceptions import NotFoundError, ValidationError
+from ..models.user import UserGroupResponse
+
+
+class UserGroupOperations(BaseOperation):
+    """Operations for STEP User Groups."""
+    def __init__(self, client, logger=None, context=None, workspace=None):
+        super().__init__(client, operation_name="UserGroupOperations", logger=logger, context=context, workspace=workspace)
+
+    @handle_rest_errors
+    def get_user_group(self, group_id: str) -> UserGroupResponse:
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("getUserGroup", {"id": group_id})
+        try:
+            r = self.client.getUserGroup(id=group_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(group_id, "UserGroup")
+            raise
+        return UserGroupResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def create_or_replace_user_group(self, group_id: str, data: dict[str, Any]) -> UserGroupResponse:
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("createOrReplaceUserGroup", {"id": group_id})
+        try:
+            r = self.client.createOrReplaceUserGroup(id=group_id, json=data, **self._build_context_params())
+        except Exception as e:
+            if "400" in str(e): raise ValidationError(str(e))
+            raise
+        return UserGroupResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def update_user_group(self, group_id: str, data: dict[str, Any]) -> UserGroupResponse:
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("updateUserGroup", {"id": group_id})
+        try:
+            r = self.client.updateUserGroup(id=group_id, json=data, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(group_id, "UserGroup")
+            raise
+        return UserGroupResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def delete_user_group(self, group_id: str) -> bool:
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("deleteUserGroup", {"id": group_id})
+        try:
+            self.client.deleteUserGroup(id=group_id, **self._build_context_params())
+            return True
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(group_id, "UserGroup")
+            raise
+
+    @handle_rest_errors
+    def get_user_group_users(self, group_id: str) -> list[dict[str, Any]]:
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("getUserGroupUsers", {"id": group_id})
+        try:
+            r = self.client.getUserGroupUsers(id=group_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(group_id, "UserGroup")
+            raise
+        return r if isinstance(r, list) else []
+
+    @handle_rest_errors
+    def get_user_group_children(self, group_id: str) -> list[str]:
+        self._validate_required_params({"group_id": group_id}, ["group_id"])
+        self._log_operation("getUserGroupChildren", {"id": group_id})
+        try:
+            r = self.client.getUserGroupChildren(id=group_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(group_id, "UserGroup")
+            raise
+        return r if isinstance(r, list) else []

stepxmlclient/rest_client/operations/users.py

@@ -0,0 +1,119 @@
+"""User operations for STEP REST API v2.
+
+Covers the /users endpoints introduced in v1.4.0.
+"""
+
+import logging
+from typing import Any
+
+from ..base import BaseOperation, handle_rest_errors
+from ..exceptions import NotFoundError, ValidationError
+from ..models.user import UserResponse
+
+
+class UserOperations(BaseOperation):
+    """Operations for STEP Users."""
+
+    def __init__(self, client, logger: logging.Logger | None = None,
+                 context: str | None = None, workspace: str | None = None):
+        super().__init__(client, operation_name="UserOperations", logger=logger,
+                         context=context, workspace=workspace)
+
+    @handle_rest_errors
+    def get_user(self, user_id: str) -> UserResponse:
+        """Get a user by ID.
+        Calls: GET /users/{id} -> getUser
+        """
+        self._validate_required_params({"user_id": user_id}, ["user_id"])
+        self._log_operation("getUser", {"id": user_id})
+        try:
+            r = self.client.getUser(id=user_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(user_id, "User")
+            raise
+        return UserResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def create_or_replace_user(self, user_id: str, data: dict[str, Any]) -> UserResponse:
+        """Create or fully replace a user.
+        Calls: PUT /users/{id} -> createOrReplaceUser
+        """
+        self._validate_required_params({"user_id": user_id}, ["user_id"])
+        self._log_operation("createOrReplaceUser", {"id": user_id})
+        try:
+            r = self.client.createOrReplaceUser(id=user_id, json=data, **self._build_context_params())
+        except Exception as e:
+            if "400" in str(e): raise ValidationError(str(e))
+            raise
+        return UserResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def update_user(self, user_id: str, data: dict[str, Any]) -> UserResponse:
+        """Partially update a user.
+        Calls: PATCH /users/{id} -> updateUser
+        """
+        self._validate_required_params({"user_id": user_id}, ["user_id"])
+        self._log_operation("updateUser", {"id": user_id})
+        try:
+            r = self.client.updateUser(id=user_id, json=data, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(user_id, "User")
+            if "400" in str(e): raise ValidationError(str(e))
+            raise
+        return UserResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def delete_user(self, user_id: str) -> bool:
+        """Delete a user.
+        Calls: DELETE /users/{id} -> deleteUser
+        """
+        self._validate_required_params({"user_id": user_id}, ["user_id"])
+        self._log_operation("deleteUser", {"id": user_id})
+        try:
+            self.client.deleteUser(id=user_id, **self._build_context_params())
+            return True
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(user_id, "User")
+            raise
+
+    @handle_rest_errors
+    def randomize_password(self, user_id: str) -> UserResponse:
+        """Randomize a user's password.
+        Calls: POST /users/{id}/randomize-password -> randomizeStepPassword
+        """
+        self._validate_required_params({"user_id": user_id}, ["user_id"])
+        self._log_operation("randomizeStepPassword", {"id": user_id})
+        try:
+            r = self.client.randomizeStepPassword(id=user_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(user_id, "User")
+            raise
+        return UserResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def add_user_to_group(self, user_id: str, group_data: dict[str, Any]) -> UserResponse:
+        """Add a user to a group.
+        Calls: POST /users/{id}/add-to-group -> addUserToGroup
+        """
+        self._validate_required_params({"user_id": user_id}, ["user_id"])
+        self._log_operation("addUserToGroup", {"id": user_id})
+        try:
+            r = self.client.addUserToGroup(id=user_id, json=group_data, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(user_id, "User")
+            raise
+        return UserResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def remove_user_from_group(self, user_id: str, group_data: dict[str, Any]) -> UserResponse:
+        """Remove a user from a group.
+        Calls: POST /users/{id}/remove-from-group -> removeUserFromGroup
+        """
+        self._validate_required_params({"user_id": user_id}, ["user_id"])
+        self._log_operation("removeUserFromGroup", {"id": user_id})
+        try:
+            r = self.client.removeUserFromGroup(id=user_id, json=group_data, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(user_id, "User")
+            raise
+        return UserResponse(**r) if isinstance(r, dict) else r

stepxmlclient/rest_client/operations/workflow_tasks.py

@@ -0,0 +1,61 @@
+"""Workflow task operations for STEP REST API v2."""
+from typing import Any
+
+from ..base import BaseOperation, handle_rest_errors
+from ..exceptions import NotFoundError
+from ..models.workflow import WorkflowTaskResponse
+
+
+class WorkflowTaskOperations(BaseOperation):
+    def __init__(self, client, logger=None, context=None, workspace=None):
+        super().__init__(client, operation_name="WorkflowTaskOperations", logger=logger, context=context, workspace=workspace)
+
+    @handle_rest_errors
+    def search_workflow_tasks(self, condition: dict[str, Any]) -> WorkflowTaskResponse:
+        self._validate_required_params({"condition": condition}, ["condition"])
+        self._log_operation("searchWorkflowTasks", {})
+        r = self.client.searchWorkflowTasks(json={"condition": condition}, **self._build_context_params())
+        return WorkflowTaskResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_workflow_task(self, task_id: str) -> WorkflowTaskResponse:
+        self._validate_required_params({"task_id": task_id}, ["task_id"])
+        self._log_operation("getWorkflowTask", {"id": task_id})
+        try:
+            r = self.client.getWorkflowTask(id=task_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(task_id, "WorkflowTask")
+            raise
+        return WorkflowTaskResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def claim_workflow_task(self, task_id: str) -> WorkflowTaskResponse:
+        self._validate_required_params({"task_id": task_id}, ["task_id"])
+        self._log_operation("claimWorkflowTask", {"id": task_id})
+        r = self.client.claimWorkflowTask(id=task_id, **self._build_context_params())
+        return WorkflowTaskResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def get_workflow_task_events(self, task_id: str) -> list[dict[str, Any]]:
+        self._validate_required_params({"task_id": task_id}, ["task_id"])
+        self._log_operation("getWorkflowTaskEvents", {"id": task_id})
+        try:
+            r = self.client.getWorkflowTaskEvents(id=task_id, **self._build_context_params())
+        except Exception as e:
+            if "404" in str(e): raise NotFoundError(task_id, "WorkflowTask")
+            raise
+        return r if isinstance(r, list) else []
+
+    @handle_rest_errors
+    def trigger_workflow_task_event(self, task_id: str, data: dict[str, Any]) -> WorkflowTaskResponse:
+        self._validate_required_params({"task_id": task_id}, ["task_id"])
+        self._log_operation("triggerWorkflowTaskEvent", {"id": task_id})
+        r = self.client.triggerWorkflowTaskEvent(id=task_id, json=data, **self._build_context_params())
+        return WorkflowTaskResponse(**r) if isinstance(r, dict) else r
+
+    @handle_rest_errors
+    def release_workflow_task(self, task_id: str) -> WorkflowTaskResponse:
+        self._validate_required_params({"task_id": task_id}, ["task_id"])
+        self._log_operation("releaseWorkflowTask", {"id": task_id})
+        r = self.client.releaseWorkflowTask(id=task_id, **self._build_context_params())
+        return WorkflowTaskResponse(**r) if isinstance(r, dict) else r