python-alfresco-api 1.1.2__tar.gz → 1.1.5__tar.gz

{python_alfresco_api-1.1.2 → python_alfresco_api-1.1.5}/CHANGELOG.md

@@ -4,7 +4,50 @@ All notable changes to python-alfresco-api will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [1.1.5] - 2025-12-14
+
+### Fixed
+- **Custom Content Type Support**: Fixed `NodeType` validation to support custom Alfresco content models (e.g., `fin:stock`, `my:invoice`)
+  - Changed `NodeType` from strict `Enum` to namespace class accepting any string type
+  - Standard types still available as constants (`NodeType.CONTENT`, `NodeType.FOLDER`)
+  - Eliminates `ValidationError` when retrieving nodes with custom types
+- **Create Folder Methods**: Fixed missing `versioning_enabled` and `major_version` parameters in convenience methods
+  - Updated `create_folder()` and `create_folder_async()` to pass required parameters to `CreateNodeRequest`
+  - Prevents linter errors about missing required parameters
+
+### Added
+- **`relative_path` Parameter**: Added explicit `relative_path` parameter to all `get_node` methods
+  - `get_node()`, `get_node_async()`, `get_node_detailed()`, `get_node_detailed_async()`
+  - Automatically converts to REST API's `relativePath` query parameter (snake_case → camelCase)
+  - Enables path-based navigation: `client.nodes.get("-root-", relative_path="Sites/mysite/documentLibrary/file.pdf")`
+- **`**kwargs` Support**: Added `**kwargs` to all `get_node` methods for forward compatibility with future API parameters
+
+## [1.1.4] - 2025-10-01
+
+### Added
+- Implemented the methods of 15 subclients that had placeholder sections
+- `test_todays_15_subclients.py` test the timeout handling the 15 subclients with the implementation methods added today
+
+### Changed
+- Same timeout fix by using the parent raw client
+- Removed some use of emojis in logging from some files to avoid errors in windows consoles
+- `pyproject.toml` version change from 1.1.2 to 1.1.4 (1.1.3 not in pypi)
+- `publish_to_pypi` removed specific version info, don't stop if test publish doesn't work since the website never works, gives 403
+
+## [1.1.3] - 2025-09-30
+
+### Fixed
+- Fixed timeout handling in 7 top level clients yesterday, this fixed 16 subclient timeout handling
+- To fix 16 subclients timeout handling and improve the code, the subclients use the raw client from the parent client instead recreating their own raw clients
+- Fixed in `authentication_client.py` to import correct raw client model packages
+
+### Changed
+- Subclients now have `raw_client()` and `httpx_client()` properties that return parent client properties and replace any `_get_raw_client()` and `get_httpx_client()` methods
+- Parent clients give subclient constructors themselves instead of client factory
+
+### Added
+- `test_client_factory_configuration.py` now also tests previous 16 subclients handling of timeout setup in addition to previous testing of the 7 parent clients
+
 
 ## [1.1.2] - 2025-09-29
 

{python_alfresco_api-1.1.2 → python_alfresco_api-1.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-alfresco-api
-Version: 1.1.2
+Version: 1.1.5
 Summary: Python Client for all Alfresco Content Services REST APIs, with Pydantic v2 Models, and Event Support
 Project-URL: Homepage, https://github.com/stevereiner/python-alfresco-api
 Project-URL: Repository, https://github.com/stevereiner/python-alfresco-api

{python_alfresco_api-1.1.2 → python_alfresco_api-1.1.5}/publish_to_pypi.py

@@ -29,7 +29,7 @@ def run_command(cmd, check=True):
 
 def main():
     """Main publishing workflow."""
-    print("🚀 PYTHON-ALFRESCO-API v1.1 PyPI PUBLISHING")
+    print("🚀 PYTHON-ALFRESCO-API PyPI PUBLISHING")
     print("=" * 50)
     
     # 1. Verify we're in the right directory
@@ -88,9 +88,15 @@ def main():
     test_response = input("🧪 Upload to Test PyPI first? (yes/no): ").lower().strip()
     if test_response == "yes":
         print("📤 Uploading to Test PyPI...")
-        run_command("python -m twine upload --repository testpypi dist/*")
-        print("✅ Test PyPI upload complete!")
-        print("🔗 Check: https://test.pypi.org/project/python-alfresco-api/")
+        test_result = run_command("python -m twine upload --repository testpypi dist/*", check=False)
+        
+        if test_result.returncode == 0:
+            print("✅ Test PyPI upload complete!")
+            print("🔗 Check: https://test.pypi.org/project/python-alfresco-api/")
+        else:
+            print("⚠️  Test PyPI upload failed (this is common)")
+            print("   Common reasons: 403 errors, authentication issues, server problems")
+            print("   Test PyPI is often unreliable - this won't prevent production upload")
         
         confirm = input("\n📤 Proceed to production PyPI? (yes/no): ").lower().strip()
         if confirm != "yes":
@@ -103,7 +109,7 @@ def main():
     
     print("\n🎉 PYPI PUBLISHING COMPLETE!")
     print("=" * 30)
-    print("✅ python-alfresco-api v1.1.1 published to PyPI")
+    print("✅ python-alfresco-api published to PyPI")
     print("🔗 Package URL: https://pypi.org/project/python-alfresco-api/")
     print("🛠️  Install with: pip install python-alfresco-api")
     

{python_alfresco_api-1.1.2 → python_alfresco_api-1.1.5}/pyproject.toml

@@ -38,7 +38,7 @@ include = [
 
 [project]
 name = "python-alfresco-api"
-version = "1.1.2"
+version = "1.1.5"
 description = "Python Client for all Alfresco Content Services REST APIs, with Pydantic v2 Models, and Event Support"
 authors = [
     {name = "Steve Reiner", email = "example@example.com"}

{python_alfresco_api-1.1.2 → python_alfresco_api-1.1.5}/python_alfresco_api/clients/__init__.py

@@ -9,11 +9,11 @@ This module provides a three-tier architecture:
 - Level 3: Operation-specific models for ONE operation
 
 Key Benefits:
-- 🚀 Better performance with lazy loading
-- 📦 Organized locality (models exactly where used)
-- 🔧 Structured imports and clear organization
-- 📋 Pydantic v2 models for better type checking in general and for AI/LLM integration
-- ⚡ Dual sync/async APIs (sync for simpler use, async for web apps)
+- [PERFORMANCE] Better performance with lazy loading
+- [ORGANIZATION] Organized locality (models exactly where used)
+- [STRUCTURE] Structured imports and clear organization
+- [MODELS] Pydantic v2 models for better type checking in general and for AI/LLM integration
+- [ASYNC] Dual sync/async APIs (sync for simpler use, async for web apps)
 """
 
 # Modern clients with three-tier architecture and lazy loading

{python_alfresco_api-1.1.2 → python_alfresco_api-1.1.5}/python_alfresco_api/clients/auth/auth_client.py

@@ -137,7 +137,7 @@ class AlfrescoAuthClient:
         if self._authentication is None:
             # Lazy load the authentication client
             from .authentication import AuthenticationClient
-            self._authentication = AuthenticationClient(self._client_factory)
+            self._authentication = AuthenticationClient(self)
         return self._authentication
     
     # =================================================================

python_alfresco_api-1.1.5/python_alfresco_api/clients/auth/authentication/authentication_client.py

@@ -0,0 +1,276 @@
+"""
+Authentication Operations Client - Level 3: Authentication-Specific Operations
+
+This module provides authentication-specific operations within the Auth API.
+Part of the three-tier V1.1 architecture with complete 4-pattern detailed functions.
+
+Each operation provides 4 variants:
+- operation(params) - basic sync with explicit parameters
+- operation_async(params) - basic async with explicit parameters  
+- operation_detailed(params) - detailed sync with explicit parameters
+- operation_detailed_async(params) - detailed async with explicit parameters
+
+Perfect for MCP servers and documentation generation.
+"""
+
+import asyncio
+from typing import Optional, List, Union, Any, Awaitable
+from httpx import Response
+
+# Import required types for proper parameter handling
+from ....raw_clients.alfresco_auth_client.auth_client.types import UNSET, Unset
+from httpx import Response
+
+# Import model types for proper parameter signatures
+from ....raw_clients.alfresco_auth_client.auth_client.models.ticket_body import TicketBody
+from ....raw_clients.alfresco_auth_client.auth_client.models.ticket_entry import TicketEntry
+from ....raw_clients.alfresco_auth_client.auth_client.models.valid_ticket_entry import ValidTicketEntry
+
+# Import from Level 3 (operation-specific models)
+from .models import AuthenticationResponse, AuthenticationListResponse, CreateAuthenticationRequest
+
+# Import raw operations
+try:
+    from ....raw_clients.alfresco_auth_client.auth_client.api.authentication import (
+            create_ticket as _create_ticket,
+            delete_ticket as _delete_ticket,
+            validate_ticket as _validate_ticket
+    )
+    RAW_OPERATIONS_AVAILABLE = True
+except ImportError:
+    RAW_OPERATIONS_AVAILABLE = False
+
+
+class AuthenticationClient:
+    """
+    Authentication operations client with 4-pattern detailed functions.
+    
+    Provides high-level methods for authentication management operations
+    that are essential for MCP servers and authentication workflows.
+    
+    Each operation has 4 variants for maximum flexibility:
+    - Basic sync/async for simple use cases
+    - Detailed sync/async for full HTTP response access
+    """
+    
+    def __init__(self, parent_client):
+        """Initialize with client factory for raw client access."""
+        self.parent_client = parent_client
+        self._raw_client = None
+        
+        # Store raw operation references
+        if RAW_OPERATIONS_AVAILABLE:
+            self._create_ticket = _create_ticket
+            self._delete_ticket = _delete_ticket
+            self._validate_ticket = _validate_ticket
+    
+    @property
+    def raw_client(self):
+        """Delegate to parent client's raw client."""
+        return self.parent_client.raw_client
+    
+    @property
+    def httpx_client(self):
+        """Delegate to parent client's httpx client."""
+        return self.parent_client.httpx_client
+    
+    # =================================================================
+    # AUTHENTICATION OPERATIONS - 4-PATTERN IMPLEMENTATION
+    # =================================================================
+    
+    def create_ticket(
+        self,
+        username: str,
+        password: str
+    ) -> Optional[Any]:
+        """
+        Create authentication ticket (sync).
+        
+        Creates a new authentication ticket for the given credentials.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        from ....raw_clients.alfresco_auth_client.auth_client.models.ticket_body import TicketBody
+        
+        ticket_body = TicketBody(user_id=username, password=password)
+        
+        return self._create_ticket.sync(
+            client=self.raw_client,
+            body=ticket_body
+        )
+    
+    async def create_ticket_async(
+        self,
+        username: str,
+        password: str
+    ) -> Optional[Any]:
+        """
+        Create authentication ticket (async).
+        
+        Creates a new authentication ticket for the given credentials.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        from ....raw_clients.alfresco_auth_client.auth_client.models.ticket_body import TicketBody
+        
+        ticket_body = TicketBody(user_id=username, password=password)
+        
+        return await self._create_ticket.asyncio(
+            client=self.raw_client,
+            body=ticket_body
+        )
+    
+    def create_ticket_detailed(
+        self,
+        username: str,
+        password: str
+    ) -> Response:
+        """
+        Create authentication ticket (detailed sync).
+        
+        Creates a new authentication ticket with full HTTP response.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        from ....raw_clients.alfresco_auth_client.auth_client.models.ticket_body import TicketBody
+        
+        ticket_body = TicketBody(user_id=username, password=password)
+        
+        return self._create_ticket.sync_detailed(
+            client=self.raw_client,
+            body=ticket_body
+        )
+    
+    async def create_ticket_detailed_async(
+        self,
+        username: str,
+        password: str
+    ) -> Response:
+        """
+        Create authentication ticket (detailed async).
+        
+        Creates a new authentication ticket with full HTTP response.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        from ....raw_clients.alfresco_auth_client.auth_client.models.ticket_body import TicketBody
+        
+        ticket_body = TicketBody(user_id=username, password=password)
+        
+        return await self._create_ticket.asyncio_detailed(
+            client=self.raw_client,
+            body=ticket_body
+        )
+    
+    def validate_ticket(self) -> Optional[Any]:
+        """
+        Validate current authentication ticket (sync).
+        
+        Validates the current authentication ticket.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return self._validate_ticket.sync(
+            client=self.raw_client
+        )
+    
+    async def validate_ticket_async(self) -> Optional[Any]:
+        """
+        Validate current authentication ticket (async).
+        
+        Validates the current authentication ticket.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return await self._validate_ticket.asyncio(
+            client=self.raw_client
+        )
+    
+    def validate_ticket_detailed(self) -> Response:
+        """
+        Validate current authentication ticket (detailed sync).
+        
+        Validates the current authentication ticket with full HTTP response.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return self._validate_ticket.sync_detailed(
+            client=self.raw_client
+        )
+    
+    async def validate_ticket_detailed_async(self) -> Response:
+        """
+        Validate current authentication ticket (detailed async).
+        
+        Validates the current authentication ticket with full HTTP response.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return await self._validate_ticket.asyncio_detailed(
+            client=self.raw_client
+        )
+    
+    def delete_ticket(self) -> Optional[Any]:
+        """
+        Delete current authentication ticket (sync).
+        
+        Deletes/invalidates the current authentication ticket.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return self._delete_ticket.sync(
+            client=self.raw_client
+        )
+    
+    async def delete_ticket_async(self) -> Optional[Any]:
+        """
+        Delete current authentication ticket (async).
+        
+        Deletes/invalidates the current authentication ticket.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return await self._delete_ticket.asyncio(
+            client=self.raw_client
+        )
+    
+    def delete_ticket_detailed(self) -> Response:
+        """
+        Delete current authentication ticket (detailed sync).
+        
+        Deletes/invalidates the current authentication ticket with full HTTP response.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return self._delete_ticket.sync_detailed(
+            client=self.raw_client
+        )
+    
+    async def delete_ticket_detailed_async(self) -> Response:
+        """
+        Delete current authentication ticket (detailed async).
+        
+        Deletes/invalidates the current authentication ticket with full HTTP response.
+        """
+        if not RAW_OPERATIONS_AVAILABLE:
+            raise ImportError("Raw authentication operations not available")
+        
+        return await self._delete_ticket.asyncio_detailed(
+            client=self.raw_client
+        )
+    
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        base_url = getattr(self.parent_client._client_factory, 'base_url', 'unknown')
+        return f"AlfrescoAuthenticationClient(base_url='{base_url}')" 

{python_alfresco_api-1.1.2 → python_alfresco_api-1.1.5}/python_alfresco_api/clients/conversion_utils.py

@@ -184,7 +184,7 @@ def enhanced_search_example():
 
 if __name__ == "__main__":
     """Test the conversion utilities."""
-    print("🔧 Testing Conversion Utilities")
+    print("[TESTING] Testing Conversion Utilities")
     
     # Test 1: Enhanced create node
     print("\n1. Enhanced create node conversion:")
@@ -194,4 +194,4 @@ if __name__ == "__main__":
     print("\n2. Enhanced search example:")
     enhanced_search_example()
     
-    print("\n✅ Conversion utilities proof-of-concept complete!") 
+    print("\n[SUCCESS] Conversion utilities proof-of-concept complete!") 

{python_alfresco_api-1.1.2 → python_alfresco_api-1.1.5}/python_alfresco_api/clients/core/actions/actions_client.py

@@ -45,9 +45,9 @@ class ActionsClient:
     - Detailed sync/async for full HTTP response access
     """
     
-    def __init__(self, client_factory):
+    def __init__(self, parent_client):
         """Initialize with client factory for raw client access."""
-        self._client_factory = client_factory
+        self.parent_client = parent_client
         self._raw_client = None
         
         # Store raw operation references
@@ -57,28 +57,15 @@ class ActionsClient:
             self._list_actions = _list_actions
             self._node_actions = _node_actions
     
-    def _get_raw_client(self):
-        """Get or create the raw client."""
-        if self._raw_client is None:
-            # Import the raw core client directly
-            from ....raw_clients.alfresco_core_client.core_client.client import AuthenticatedClient
-            
-            # Create the raw client with same auth setup
-            self._raw_client = AuthenticatedClient(
-                base_url=f"{self._client_factory.base_url}/alfresco/api/-default-/public/alfresco/versions/1",
-                token=self._client_factory.auth.get_auth_token(),
-                prefix=self._client_factory.auth.get_auth_prefix(),
-                verify_ssl=self._client_factory.verify_ssl
-            )
-        return self._raw_client
+    @property
+    def raw_client(self):
+        """Delegate to parent client's raw client."""
+        return self.parent_client.raw_client
     
-    def get_httpx_client(self):
-        """
-        Get direct access to raw httpx client for advanced operations.
-        
-        Perfect for MCP servers that need raw HTTP access.
-        """
-        return self._get_raw_client().get_httpx_client()
+    @property
+    def httpx_client(self):
+        """Delegate to parent client's httpx client."""
+        return self.parent_client.httpx_client
     
     # ==================== 4-PATTERN OPERATIONS ====================
 
@@ -94,7 +81,7 @@ class ActionsClient:
         if not hasattr(self, '_action_details'):
             raise ImportError("Raw client operation not available")
         
-        result = self._action_details.sync(client=self._get_raw_client(), action_definition_id=action_definition_id)
+        result = self._action_details.sync(client=self.raw_client, action_definition_id=action_definition_id)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -110,7 +97,7 @@ class ActionsClient:
         if not hasattr(self, '_action_details'):
             raise ImportError("Raw client operation not available")
         
-        result = await self._action_details.asyncio(client=self._get_raw_client(), action_definition_id=action_definition_id)
+        result = await self._action_details.asyncio(client=self.raw_client, action_definition_id=action_definition_id)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -126,7 +113,7 @@ class ActionsClient:
         if not hasattr(self, '_action_details'):
             raise ImportError("Raw client operation not available")
         
-        return self._action_details.sync_detailed(client=self._get_raw_client(), action_definition_id=action_definition_id)
+        return self._action_details.sync_detailed(client=self.raw_client, action_definition_id=action_definition_id)
     
     async def action_details_detailed_async(self, action_definition_id: Any):
         """
@@ -138,7 +125,7 @@ class ActionsClient:
         if not hasattr(self, '_action_details'):
             raise ImportError("Raw client operation not available")
         
-        return await self._action_details.asyncio_detailed(client=self._get_raw_client(), action_definition_id=action_definition_id)
+        return await self._action_details.asyncio_detailed(client=self.raw_client, action_definition_id=action_definition_id)
 
     # ==================== ACTION_EXEC OPERATION ====================
     
@@ -152,7 +139,7 @@ class ActionsClient:
         if not hasattr(self, '_action_exec'):
             raise ImportError("Raw client operation not available")
         
-        result = self._action_exec.sync(client=self._get_raw_client(), body=body)
+        result = self._action_exec.sync(client=self.raw_client, body=body)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -168,7 +155,7 @@ class ActionsClient:
         if not hasattr(self, '_action_exec'):
             raise ImportError("Raw client operation not available")
         
-        result = await self._action_exec.asyncio(client=self._get_raw_client(), body=body)
+        result = await self._action_exec.asyncio(client=self.raw_client, body=body)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -184,7 +171,7 @@ class ActionsClient:
         if not hasattr(self, '_action_exec'):
             raise ImportError("Raw client operation not available")
         
-        return self._action_exec.sync_detailed(client=self._get_raw_client(), body=body)
+        return self._action_exec.sync_detailed(client=self.raw_client, body=body)
     
     async def action_exec_detailed_async(self, body: Any):
         """
@@ -196,7 +183,7 @@ class ActionsClient:
         if not hasattr(self, '_action_exec'):
             raise ImportError("Raw client operation not available")
         
-        return await self._action_exec.asyncio_detailed(client=self._get_raw_client(), body=body)
+        return await self._action_exec.asyncio_detailed(client=self.raw_client, body=body)
 
     # ==================== LIST_ACTIONS OPERATION ====================
     
@@ -210,7 +197,7 @@ class ActionsClient:
         if not hasattr(self, '_list_actions'):
             raise ImportError("Raw client operation not available")
         
-        result = self._list_actions.sync(client=self._get_raw_client(), skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        result = self._list_actions.sync(client=self.raw_client, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -226,7 +213,7 @@ class ActionsClient:
         if not hasattr(self, '_list_actions'):
             raise ImportError("Raw client operation not available")
         
-        result = await self._list_actions.asyncio(client=self._get_raw_client(), skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        result = await self._list_actions.asyncio(client=self.raw_client, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -242,7 +229,7 @@ class ActionsClient:
         if not hasattr(self, '_list_actions'):
             raise ImportError("Raw client operation not available")
         
-        return self._list_actions.sync_detailed(client=self._get_raw_client(), skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        return self._list_actions.sync_detailed(client=self.raw_client, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
     
     async def list_actions_detailed_async(self, skip_count: Any, max_items: Any, order_by: Any, fields: Any):
         """
@@ -254,7 +241,7 @@ class ActionsClient:
         if not hasattr(self, '_list_actions'):
             raise ImportError("Raw client operation not available")
         
-        return await self._list_actions.asyncio_detailed(client=self._get_raw_client(), skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        return await self._list_actions.asyncio_detailed(client=self.raw_client, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
 
     # ==================== NODE_ACTIONS OPERATION ====================
     
@@ -268,7 +255,7 @@ class ActionsClient:
         if not hasattr(self, '_node_actions'):
             raise ImportError("Raw client operation not available")
         
-        result = self._node_actions.sync(client=self._get_raw_client(), node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        result = self._node_actions.sync(client=self.raw_client, node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -284,7 +271,7 @@ class ActionsClient:
         if not hasattr(self, '_node_actions'):
             raise ImportError("Raw client operation not available")
         
-        result = await self._node_actions.asyncio(client=self._get_raw_client(), node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        result = await self._node_actions.asyncio(client=self.raw_client, node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
         
         # Convert to standardized response
         from ..models import BaseEntry
@@ -300,7 +287,7 @@ class ActionsClient:
         if not hasattr(self, '_node_actions'):
             raise ImportError("Raw client operation not available")
         
-        return self._node_actions.sync_detailed(client=self._get_raw_client(), node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        return self._node_actions.sync_detailed(client=self.raw_client, node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
     
     async def node_actions_detailed_async(self, node_id: Any, skip_count: Any, max_items: Any, order_by: Any, fields: Any):
         """
@@ -312,7 +299,7 @@ class ActionsClient:
         if not hasattr(self, '_node_actions'):
             raise ImportError("Raw client operation not available")
         
-        return await self._node_actions.asyncio_detailed(client=self._get_raw_client(), node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
+        return await self._node_actions.asyncio_detailed(client=self.raw_client, node_id=node_id, skip_count=skip_count, max_items=max_items, order_by=order_by, fields=fields)
     
     def __repr__(self) -> str:
         """String representation for debugging."""