python-alfresco-api 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

python_alfresco_api/__init__.py

@@ -33,7 +33,10 @@ from .clients.conversion_utils import (
     create_converter_pair
 )
 
-__version__ = "1.0.0"
+# Import raw_clients to ensure they get packaged
+from . import raw_clients
+
+__version__ = "1.1.1"
 __all__ = [
     # Factory & utilities
     "ClientFactory",
@@ -52,5 +55,8 @@ __all__ = [
     # Conversion utilities
     "pydantic_to_attrs_dict",
     "attrs_to_pydantic", 
-    "create_converter_pair"
+    "create_converter_pair",
+    
+    # Raw clients
+    "raw_clients"
 ]

python_alfresco_api/auth_util.py

@@ -24,6 +24,7 @@ def load_env_config(
     username: Optional[str] = None,
     password: Optional[str] = None,
     verify_ssl: Optional[Union[bool, str]] = None,
+    timeout: Optional[int] = None,
     load_env: bool = True,
     env_file: Optional[str] = None
 ) -> Dict[str, Any]:
@@ -37,6 +38,7 @@ def load_env_config(
         username: Explicit username (overrides env) 
         password: Explicit password (overrides env)
         verify_ssl: SSL verification - True/False or path to certificate bundle (overrides env)
+        timeout: Request timeout in seconds (overrides env)
         load_env: Whether to load from environment/.env file
         env_file: Specific .env file path
         
@@ -55,6 +57,19 @@ def load_env_config(
     resolved_username = username or os.getenv('ALFRESCO_USERNAME') or 'admin'
     resolved_password = password or os.getenv('ALFRESCO_PASSWORD') or 'admin'
     
+    # Handle timeout with environment variable support
+    if timeout is not None:
+        resolved_timeout = timeout
+    else:
+        timeout_env = os.getenv('ALFRESCO_TIMEOUT')
+        if timeout_env:
+            try:
+                resolved_timeout = int(timeout_env)
+            except ValueError:
+                resolved_timeout = None  # Invalid value, don't set timeout
+        else:
+            resolved_timeout = None  # No timeout specified, let system/client defaults apply
+    
     # Handle SSL verification (supports bool or certificate path like raw client)
     if verify_ssl is not None:
         resolved_verify_ssl = verify_ssl
@@ -73,7 +88,8 @@ def load_env_config(
         'base_url': resolved_base_url,
         'username': resolved_username,
         'password': resolved_password,
-        'verify_ssl': resolved_verify_ssl
+        'verify_ssl': resolved_verify_ssl,
+        'timeout': resolved_timeout
     }
 
 class SimpleAuthUtil:
@@ -130,7 +146,7 @@ class AuthUtil:
         username: str,
         password: str,
         verify_ssl: Union[bool, str] = True,
-        timeout: int = 30
+        timeout: Optional[int] = None
     ):
         """
         Initialize authentication utility.
@@ -140,7 +156,7 @@ class AuthUtil:
             username: Alfresco username
             password: Alfresco password
             verify_ssl: SSL verification - True, False, or path to certificate bundle
-            timeout: Request timeout in seconds
+            timeout: Request timeout in seconds (None = use system defaults)
         """
         self.base_url = base_url.rstrip('/')
         self.username = username
@@ -167,7 +183,12 @@ class AuthUtil:
             auth_url = f"{self.base_url}/alfresco/api/-default-/public/authentication/versions/1/tickets"
             auth_data = {"userId": self.username, "password": self.password}
             
-            async with httpx.AsyncClient(verify=self.verify_ssl, timeout=self.timeout) as client:
+            # Create httpx client with timeout only if specified
+            client_kwargs = {"verify": self.verify_ssl}
+            if self.timeout is not None:
+                client_kwargs["timeout"] = self.timeout
+            
+            async with httpx.AsyncClient(**client_kwargs) as client:
                 response = await client.post(auth_url, json=auth_data)
                 
                 if response.status_code == 201:
@@ -338,7 +359,7 @@ class OAuth2AuthUtil:
         refresh_token: Optional[str] = None,
         # Standard auth util parameters
         verify_ssl: Union[bool, str] = True,
-        timeout: int = 30,
+        timeout: Optional[int] = None,
         # Environment loading
         load_env: bool = True,
         env_file: Optional[str] = None
@@ -358,7 +379,7 @@ class OAuth2AuthUtil:
             access_token: Existing access token (optional)
             refresh_token: Existing refresh token (optional)
             verify_ssl: SSL verification - True, False, or path to certificate bundle
-            timeout: Request timeout in seconds
+            timeout: Request timeout in seconds (None = use system defaults)
             load_env: Whether to load configuration from environment
             env_file: Optional path to .env file
         """
@@ -477,7 +498,12 @@ class OAuth2AuthUtil:
         if self.scope:
             data["scope"] = self.scope
         
-        async with httpx.AsyncClient(verify=self.verify_ssl, timeout=self.timeout) as client:
+        # Create httpx client with timeout only if specified
+        client_kwargs = {"verify": self.verify_ssl}
+        if self.timeout is not None:
+            client_kwargs["timeout"] = self.timeout
+        
+        async with httpx.AsyncClient(**client_kwargs) as client:
             response = await client.post(
                 self.token_endpoint,
                 data=data,
@@ -516,7 +542,12 @@ class OAuth2AuthUtil:
         if self.client_secret:
             data["client_secret"] = self.client_secret
         
-        async with httpx.AsyncClient(verify=self.verify_ssl, timeout=self.timeout) as client:
+        # Create httpx client with timeout only if specified
+        client_kwargs = {"verify": self.verify_ssl}
+        if self.timeout is not None:
+            client_kwargs["timeout"] = self.timeout
+        
+        async with httpx.AsyncClient(**client_kwargs) as client:
             response = await client.post(
                 self.token_endpoint,
                 data=data,

python_alfresco_api/client_factory.py

@@ -54,7 +54,7 @@ class ClientFactory:
         password: Optional[str] = None,
         auth_util = None,  # Pass existing auth_util (any type)
         verify_ssl: Optional[Union[bool, str]] = None,
-        timeout: int = 30,
+        timeout: Optional[int] = None,
         load_env: bool = True,
         env_file: Optional[str] = None
     ):
@@ -69,8 +69,9 @@ class ClientFactory:
             username: Username for authentication (overrides env)
             password: Password for authentication (overrides env)
             auth_util: Pre-configured auth util (SimpleAuthUtil, AuthUtil, OAuth2AuthUtil, etc.)
+                      If provided, its parameters (timeout, base_url, verify_ssl) take priority
             verify_ssl: SSL verification - True, False, or path to certificate bundle (overrides env)
-            timeout: Request timeout in seconds
+            timeout: Request timeout in seconds (overrides env, but auth_util.timeout takes precedence)
             load_env: Whether to automatically load from environment/env file
             env_file: Specific .env file path (default: .env in current directory)
         """
@@ -81,6 +82,7 @@ class ClientFactory:
             username=username, 
             password=password,
             verify_ssl=verify_ssl,
+            timeout=timeout,
             load_env=load_env,
             env_file=env_file
         )
@@ -88,21 +90,45 @@ class ClientFactory:
         # Store resolved configuration
         self._base_url = config['base_url']
         self.verify_ssl = config['verify_ssl']
-        self.timeout = timeout
+        self.timeout = config['timeout']  # May be None if not specified
         
         # Handle authentication centrally - support all patterns
         if auth_util is not None:
             # Use provided auth_util (any type: SimpleAuthUtil, AuthUtil, OAuth2AuthUtil)
+            # Respect auth_util's existing configuration if it has parameters
             self.auth = auth_util
+            
+            # If auth_util has its own timeout, use it; otherwise use our resolved timeout
+            if hasattr(auth_util, 'timeout') and auth_util.timeout is not None:
+                self.timeout = auth_util.timeout
+            
+            # If auth_util has its own base_url, use it; otherwise keep our resolved base_url
+            if hasattr(auth_util, 'base_url') and auth_util.base_url:
+                self._base_url = auth_util.base_url
+                
+            # If auth_util has its own verify_ssl, use it; otherwise keep our resolved verify_ssl
+            if hasattr(auth_util, 'verify_ssl') and auth_util.verify_ssl is not None:
+                self.verify_ssl = auth_util.verify_ssl
+                
+            # Store auth_util credentials for access (don't override the auth_util itself)
+            self._auth_username = getattr(auth_util, 'username', None)
+            self._auth_password = getattr(auth_util, 'password', None)
         elif config['username'] and config['password']:
             # Create full AuthUtil with query parameter support (including from env)
-            self.auth = AuthUtil(
-                base_url=config['base_url'],
-                username=config['username'], 
-                password=config['password'],
-                verify_ssl=config['verify_ssl'],
-                timeout=timeout
-            )
+            # Only pass timeout if it's specified (not None)
+            auth_kwargs = {
+                'base_url': config['base_url'],
+                'username': config['username'], 
+                'password': config['password'],
+                'verify_ssl': config['verify_ssl']
+            }
+            if config['timeout'] is not None:
+                auth_kwargs['timeout'] = config['timeout']
+            
+            self.auth = AuthUtil(**auth_kwargs)
+            # Store credentials for access
+            self._auth_username = config['username']
+            self._auth_password = config['password']
         else:
             # No authentication available
             raise ValueError(
@@ -117,6 +143,16 @@ class ClientFactory:
         """Get the server base URL."""
         return self._base_url
     
+    @property
+    def username(self) -> Optional[str]:
+        """Get the authentication username."""
+        return getattr(self, '_auth_username', None)
+    
+    @property
+    def password(self) -> Optional[str]:
+        """Get the authentication password."""
+        return getattr(self, '_auth_password', None)
+    
     @classmethod
     def from_env(cls, env_file: Optional[str] = None) -> 'ClientFactory':
         """

python_alfresco_api/clients/__init__.py

@@ -55,6 +55,6 @@ __all__ = [
 ]
 
 # Module metadata for discovery
-__version__ = "1.1.0"
+__version__ = "1.1.1"
 __description__ = "Alfresco API Clients with three-tier architecture and lazy loading"
 __author__ = "Python Alfresco API Project"

python_alfresco_api/clients/auth/__init__.py

@@ -10,5 +10,8 @@ from .models import AuthResponse, AuthRequest
 # Import the main client class
 from .auth_client import AlfrescoAuthClient
 
-# Export the client class
-__all__ = ['AlfrescoAuthClient', 'AuthResponse', 'AuthRequest']
+# Import models module itself to ensure it gets packaged
+from . import models
+
+# Export the client class, models, and the models module itself
+__all__ = ['AlfrescoAuthClient', 'AuthResponse', 'AuthRequest', 'models']

python_alfresco_api/clients/auth/auth_client.py

@@ -80,12 +80,19 @@ class AlfrescoAuthClient:
         """
         from ...raw_clients.alfresco_auth_client.auth_client.client import AuthenticatedClient
         
-        return AuthenticatedClient(
-            base_url=f"{self._client_factory.base_url}/alfresco/api/-default-/public/authentication/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
-        )
+        # Prepare client arguments
+        client_kwargs = {
+            "base_url": f"{self._client_factory.base_url}/alfresco/api/-default-/public/authentication/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
+        }
+        
+        # Only add timeout if specified (not None)
+        if self._client_factory.timeout is not None:
+            client_kwargs["timeout"] = self._client_factory.timeout
+        
+        return AuthenticatedClient(**client_kwargs)
     
     def _create_httpx_client(self):
         """

python_alfresco_api/clients/auth/authentication/__init__.py

@@ -6,5 +6,6 @@ Part of the three-tier V1.1 architecture with complete 4-pattern detailed functi
 """
 
 from .authentication_client import AuthenticationClient
+from . import models
 
-__all__ = ['AuthenticationClient']
+__all__ = ['AuthenticationClient', 'models']

python_alfresco_api/clients/core/__init__.py

@@ -8,4 +8,17 @@ and other repository operations through a clean, lazy-loaded interface.
 # Import the client class from separate file
 from .core_client import AlfrescoCoreClient
 
-__all__ = ['AlfrescoCoreClient'] 
+# Import all submodules to ensure they get packaged
+from . import actions, activities, audit, comments, content, downloads
+from . import favorites, groups, networks, nodes, people, preferences
+from . import probes, queries, ratings, renditions, shared_links, sites
+from . import tags, trashcan, versions, models
+
+__all__ = [
+    'AlfrescoCoreClient',
+    # All lazy-loaded submodules and models
+    'actions', 'activities', 'audit', 'comments', 'content', 'downloads',
+    'favorites', 'groups', 'networks', 'nodes', 'people', 'preferences', 
+    'probes', 'queries', 'ratings', 'renditions', 'shared_links', 'sites',
+    'tags', 'trashcan', 'versions', 'models'
+] 

python_alfresco_api/clients/core/actions/__init__.py

@@ -6,5 +6,6 @@ Part of the three-tier V1.1 architecture with complete 4-pattern detailed functi
 """
 
 from .actions_client import ActionsClient
+from . import models
 
-__all__ = ['ActionsClient']
+__all__ = ['ActionsClient', 'models']

python_alfresco_api/clients/core/activities/__init__.py

@@ -6,5 +6,6 @@ Part of the three-tier V1.1 architecture with complete 4-pattern detailed functi
 """
 
 from .activities_client import ActivitiesClient
+from . import models
 
-__all__ = ['ActivitiesClient']
+__all__ = ['ActivitiesClient', 'models']

python_alfresco_api/clients/core/audit/__init__.py

@@ -6,5 +6,6 @@ Part of the three-tier V1.1 architecture with complete 4-pattern detailed functi
 """
 
 from .audit_client import AuditClient
+from . import models
 
-__all__ = ['AuditClient']
+__all__ = ['AuditClient', 'models']

python_alfresco_api/clients/core/comments/__init__.py

@@ -6,5 +6,6 @@ Part of the three-tier V1.1 architecture with complete 4-pattern detailed functi
 """
 
 from .comments_client import CommentsClient
+from . import models
 
-__all__ = ['CommentsClient']
+__all__ = ['CommentsClient', 'models']

python_alfresco_api/clients/core/content/__init__.py

@@ -7,9 +7,10 @@ Part of the three-tier V1.1 architecture.
 
 # Import from Level 3 (operation-specific models)
 from .models import UploadResponse, DownloadResponse
+from . import models
 
 # Import the main client class
 from .content_client import ContentClient
 
 # Export the client class and models
-__all__ = ['ContentClient', 'UploadResponse', 'DownloadResponse'] 
+__all__ = ['ContentClient', 'UploadResponse', 'DownloadResponse', 'models'] 

python_alfresco_api/clients/core/core_client.py

@@ -138,13 +138,20 @@ class AlfrescoCoreClient:
         # 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
-        return 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
-        )
+        # Prepare client arguments
+        client_kwargs = {
+            "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
+        }
+        
+        # Only add timeout if specified (not None)
+        if self._client_factory.timeout is not None:
+            client_kwargs["timeout"] = self._client_factory.timeout
+        
+        # Create the raw client with auth setup
+        return AuthenticatedClient(**client_kwargs)
     
     def _create_httpx_client(self):
         """
@@ -437,4 +444,15 @@ class AlfrescoCoreClient:
     def __repr__(self) -> str:
         """String representation for debugging."""
         base_url = getattr(self._client_factory, 'base_url', 'unknown')
-        return f"AlfrescoCoreClient(base_url='{base_url}')" 
+        return f"AlfrescoCoreClient(base_url='{base_url}')"
+
+# Export the main client class and all lazy-loaded sub-modules
+# This ensures packaging systems include all dynamically accessed modules
+__all__ = [
+    'AlfrescoCoreClient',
+    # Lazy-loaded sub-clients (accessed via properties)
+    'actions', 'activities', 'audit', 'comments', 'content', 'downloads',
+    'favorites', 'groups', 'networks', 'nodes', 'people', 'preferences', 
+    'probes', 'queries', 'ratings', 'renditions', 'shared_links', 'sites',
+    'tags', 'trashcan', 'versions'
+] 

python_alfresco_api/clients/core/downloads/__init__.py

@@ -0,0 +1,11 @@
+"""
+Downloads Operations Client - Level 3: Downloads-Specific Operations
+
+This module provides downloads-specific operations within the Core API.
+Part of the three-tier V1.1 architecture with complete 4-pattern detailed functions.
+"""
+
+from .downloads_client import DownloadsClient
+from . import models
+
+__all__ = ['DownloadsClient', 'models']

python_alfresco_api/clients/core/downloads/downloads_client.py

@@ -0,0 +1,190 @@
+"""
+Downloads Operations Client - Level 3: Downloads-Specific Operations
+
+This module provides downloads-specific operations within the Core 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
+from httpx import Response
+
+# Import from Level 3 (operation-specific models)
+from .models import DownloadsResponse, DownloadsListResponse, CreateDownloadsRequest
+
+# Import raw operations
+try:
+    from ....raw_clients.alfresco_core_client.core_client.api.downloads import (
+            cancel_download as _cancel_download,
+            create_download as _create_download,
+            get_download as _get_download
+    )
+    RAW_OPERATIONS_AVAILABLE = True
+except ImportError:
+    RAW_OPERATIONS_AVAILABLE = False
+
+
+class DownloadsClient:
+    """
+    Downloads operations client with 4-pattern detailed functions.
+    
+    Provides high-level methods for downloads management operations
+    that are essential for MCP servers and downloads 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, client_factory):
+        """Initialize with client factory for raw client access."""
+        self._client_factory = client_factory
+        self._raw_client = None
+        
+        # Store raw operation references
+        if RAW_OPERATIONS_AVAILABLE:
+            self._cancel_download = _cancel_download
+            self._create_download = _create_download
+            self._get_download = _get_download
+    
+    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
+    
+    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()
+
+    # ==================== CANCEL_DOWNLOAD OPERATION ====================
+    
+    def cancel_download(self, download_id: str) -> Any:
+        """Cancel Download operation."""
+        from ....raw_clients.alfresco_core_client.core_client.api.downloads import cancel_download
+        return cancel_download.sync(client=self._get_raw_client(), download_id=download_id)
+    
+    async def cancel_download_async(self, download_id: str) -> Any:
+        """Cancel Download operation (async)."""
+        from ....raw_clients.alfresco_core_client.core_client.api.downloads import cancel_download
+        return await cancel_download.asyncio(client=self._get_raw_client(), download_id=download_id)
+    
+    def cancel_download_detailed(self, download_id: str) -> Response:
+        """Cancel Download operation (detailed)."""
+        from ....raw_clients.alfresco_core_client.core_client.api.downloads import cancel_download
+        return cancel_download.sync_detailed(client=self._get_raw_client(), download_id=download_id)
+    
+    async def cancel_download_detailed_async(self, download_id: str) -> Response:
+        """Cancel Download operation (detailed, async)."""
+        from ....raw_clients.alfresco_core_client.core_client.api.downloads import cancel_download
+        return await cancel_download.asyncio_detailed(client=self._get_raw_client(), download_id=download_id)
+
+    # ==================== CREATE_DOWNLOAD OPERATION ====================
+    
+    def create_download(self, body: Any, fields: Optional[List[str]] = None) -> Any:
+        """Create Download operation."""
+        from ....raw_clients.alfresco_core_client.core_client.api.downloads import create_download
+        from ....raw_clients.alfresco_core_client.core_client.types import UNSET
+        return create_download.sync(
+            client=self._get_raw_client(), 
+            body=body, 
+            fields=fields if fields is not None else UNSET
+        )
+    
+    async def create_download_async(self, body: Any, fields: Optional[List[str]] = None) -> Any:
+        """Create Download operation (async)."""
+        from ....raw_clients.alfresco_core_client.core_client.api.downloads import create_download
+        from ....raw_clients.alfresco_core_client.core_client.types import UNSET
+        return await create_download.asyncio(
+            client=self._get_raw_client(), 
+            body=body, 
+            fields=fields if fields is not None else UNSET
+        )
+    
+    def create_download_detailed(self, body: Any, fields: Optional[List[str]] = None) -> Response:
+        """Create Download operation (detailed)."""
+        from ....raw_clients.alfresco_core_client.core_client.api.downloads import create_download
+        from ....raw_clients.alfresco_core_client.core_client.types import UNSET
+        return create_download.sync_detailed(
+            client=self._get_raw_client(), 
+            body=body, 
+            fields=fields if fields is not None else UNSET
+        )
+    
+    async def create_download_detailed_async(self, body: Any, fields: Optional[List[str]] = None) -> Response:
+        """Create Download operation (detailed, async)."""
+        from ....raw_clients.alfresco_core_client.core_client.api.downloads import create_download
+        from ....raw_clients.alfresco_core_client.core_client.types import UNSET
+        return await create_download.asyncio_detailed(
+            client=self._get_raw_client(), 
+            body=body, 
+            fields=fields if fields is not None else UNSET
+        )
+
+    # ==================== GET_DOWNLOAD OPERATION ====================
+    
+    def get_download(self, download_id: str, fields: Optional[List[str]] = None) -> Any:
+        """Get Download operation."""
+        from ....raw_clients.alfresco_core_client.core_client.api.downloads import get_download
+        from ....raw_clients.alfresco_core_client.core_client.types import UNSET
+        return get_download.sync(
+            client=self._get_raw_client(), 
+            download_id=download_id, 
+            fields=fields if fields is not None else UNSET
+        )
+    
+    async def get_download_async(self, download_id: str, fields: Optional[List[str]] = None) -> Any:
+        """Get Download operation (async)."""
+        from ....raw_clients.alfresco_core_client.core_client.api.downloads import get_download
+        from ....raw_clients.alfresco_core_client.core_client.types import UNSET
+        return await get_download.asyncio(
+            client=self._get_raw_client(), 
+            download_id=download_id, 
+            fields=fields if fields is not None else UNSET
+        )
+    
+    def get_download_detailed(self, download_id: str, fields: Optional[List[str]] = None) -> Response:
+        """Get Download operation (detailed)."""
+        from ....raw_clients.alfresco_core_client.core_client.api.downloads import get_download
+        from ....raw_clients.alfresco_core_client.core_client.types import UNSET
+        return get_download.sync_detailed(
+            client=self._get_raw_client(), 
+            download_id=download_id, 
+            fields=fields if fields is not None else UNSET
+        )
+    
+    async def get_download_detailed_async(self, download_id: str, fields: Optional[List[str]] = None) -> Response:
+        """Get Download operation (detailed, async)."""
+        from ....raw_clients.alfresco_core_client.core_client.api.downloads import get_download
+        from ....raw_clients.alfresco_core_client.core_client.types import UNSET
+        return await get_download.asyncio_detailed(
+            client=self._get_raw_client(), 
+            download_id=download_id, 
+            fields=fields if fields is not None else UNSET
+        )
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        base_url = getattr(self._client_factory, 'base_url', 'unknown')
+        return f"DownloadsClient(base_url='{base_url}')"