binalyze-air-sdk 1.0.2__py3-none-any.whl → 1.0.3__py3-none-any.whl

binalyze_air/__init__.py

@@ -1,77 +1,77 @@
-"""
-Binalyze AIR Python SDK
-
-A comprehensive Python SDK for interacting with the Binalyze AIR API using CQRS architecture.
-"""
-
-from .client import AIRClient
-from .config import AIRConfig
-from .exceptions import (
-    AIRAPIError,
-    AuthenticationError,
-    NotFoundError,
-    ValidationError,
-    RateLimitError,
-)
-
-# Export commonly used models
-from .models import (
-    # Assets
-    Asset, AssetDetail, AssetTask, AssetFilter, AssetTaskFilter,
-    # Cases
-    Case, CaseActivity, CaseEndpoint, CaseTask, User, CaseFilter, CaseActivityFilter,
-    CreateCaseRequest, UpdateCaseRequest, CaseStatus,
-    # Tasks
-    Task, TaskFilter, TaskStatus, TaskType,
-    # Acquisitions
-    AcquisitionProfile, AcquisitionProfileDetails, AcquisitionFilter,
-    AcquisitionTaskRequest, ImageAcquisitionTaskRequest, CreateAcquisitionProfileRequest,
-    AuditLog, AuditFilter, AuditLogsFilter, AuditSummary, AuditUserActivity, AuditSystemEvent,
-)
-
-__version__ = "1.0.1"
-__all__ = [
-    # Core classes
-    "AIRClient",
-    "AIRConfig", 
-    
-    # Exceptions
-    "AIRAPIError",
-    "AuthenticationError",
-    "NotFoundError",
-    "ValidationError",
-    "RateLimitError",
-    
-    # Asset models
-    "Asset",
-    "AssetDetail",
-    "AssetTask",
-    "AssetFilter",
-    "AssetTaskFilter",
-    
-    # Case models
-    "Case",
-    "CaseActivity",
-    "CaseEndpoint",
-    "CaseTask",
-    "User",
-    "CaseFilter",
-    "CaseActivityFilter",
-    "CreateCaseRequest",
-    "UpdateCaseRequest",
-    "CaseStatus",
-    
-    # Task models
-    "Task",
-    "TaskFilter",
-    "TaskStatus",
-    "TaskType",
-    
-    # Acquisition models
-    "AcquisitionProfile",
-    "AcquisitionProfileDetails",
-    "AcquisitionFilter",
-    "AcquisitionTaskRequest",
-    "ImageAcquisitionTaskRequest",
-    "CreateAcquisitionProfileRequest",
-] 
+"""
+Binalyze AIR Python SDK
+
+A comprehensive Python SDK for interacting with the Binalyze AIR API using CQRS architecture.
+"""
+
+from .client import AIRClient
+from .config import AIRConfig
+from .exceptions import (
+    AIRAPIError,
+    AuthenticationError,
+    NotFoundError,
+    ValidationError,
+    RateLimitError,
+)
+
+# Export commonly used models
+from .models import (
+    # Assets
+    Asset, AssetDetail, AssetTask, AssetFilter, AssetTaskFilter,
+    # Cases
+    Case, CaseActivity, CaseEndpoint, CaseTask, User, CaseFilter, CaseActivityFilter,
+    CreateCaseRequest, UpdateCaseRequest, CaseStatus,
+    # Tasks
+    Task, TaskFilter, TaskStatus, TaskType,
+    # Acquisitions
+    AcquisitionProfile, AcquisitionProfileDetails, AcquisitionFilter,
+    AcquisitionTaskRequest, ImageAcquisitionTaskRequest, CreateAcquisitionProfileRequest,
+    AuditLog, AuditFilter, AuditLogsFilter, AuditSummary, AuditUserActivity, AuditSystemEvent,
+)
+
+__version__ = "1.0.1"
+__all__ = [
+    # Core classes
+    "AIRClient",
+    "AIRConfig",
+
+    # Exceptions
+    "AIRAPIError",
+    "AuthenticationError",
+    "NotFoundError",
+    "ValidationError",
+    "RateLimitError",
+
+    # Asset models
+    "Asset",
+    "AssetDetail",
+    "AssetTask",
+    "AssetFilter",
+    "AssetTaskFilter",
+
+    # Case models
+    "Case",
+    "CaseActivity",
+    "CaseEndpoint",
+    "CaseTask",
+    "User",
+    "CaseFilter",
+    "CaseActivityFilter",
+    "CreateCaseRequest",
+    "UpdateCaseRequest",
+    "CaseStatus",
+
+    # Task models
+    "Task",
+    "TaskFilter",
+    "TaskStatus",
+    "TaskType",
+
+    # Acquisition models
+    "AcquisitionProfile",
+    "AcquisitionProfileDetails",
+    "AcquisitionFilter",
+    "AcquisitionTaskRequest",
+    "ImageAcquisitionTaskRequest",
+    "CreateAcquisitionProfileRequest",
+]

binalyze_air/apis/__init__.py

@@ -1,27 +1,67 @@
-"""
-API classes for the Binalyze AIR SDK.
-"""
-
-from .event_subscription import EventSubscriptionAPI
-from .interact import InteractAPI
-from .params import ParamsAPI
-from .settings import SettingsAPI
-from .endpoints import EndpointsAPI
-from .evidences import EvidencesAPI
-from .authentication import AuthenticationAPI
-from .user_management import UserManagementAPI
-from .evidence import EvidenceAPI
-from .auto_asset_tags import AutoAssetTagsAPI
-
-__all__ = [
-    "EventSubscriptionAPI",
-    "InteractAPI", 
-    "ParamsAPI",
-    "SettingsAPI",
-    "EndpointsAPI",
-    "EvidencesAPI",
-    "AuthenticationAPI",
-    "UserManagementAPI",
-    "EvidenceAPI",
-    "AutoAssetTagsAPI",
-]
+"""
+API classes for the Binalyze AIR SDK.
+"""
+
+from .assets import AssetsAPI
+from .cases import CasesAPI
+from .tasks import TasksAPI
+from .acquisitions import AcquisitionsAPI
+from .policies import PoliciesAPI
+from .organizations import OrganizationsAPI
+from .triage import TriageAPI
+from .audit_logs import AuditAPI
+from .baseline import BaselineAPI
+from .auth import AuthAPI
+from .evidence import EvidenceAPI
+from .auto_asset_tags import AutoAssetTagsAPI
+from .event_subscription import EventSubscriptionAPI
+from .interact import InteractAPI
+from .params import ParamsAPI
+from .settings import SettingsAPI
+from .webhooks import WebhookAPI
+from .api_tokens import APITokensAPI
+from .investigation_hub import InvestigationHubAPI
+from .cloud_forensics import CloudForensicsAPI
+from .backup import BackupAPI
+from .license import LicenseAPI
+from .logger import LoggerAPI
+from .multipart_upload import MultipartUploadAPI
+from .notifications import NotificationsAPI
+from .preset_filters import PresetFiltersAPI
+from .recent_activities import RecentActivitiesAPI
+from .relay_server import RelayServerAPI
+from .webhook_executions import WebhookExecutionsAPI
+from .user_management import UserManagementAPI
+
+__all__ = [
+    "AssetsAPI",
+    "CasesAPI", 
+    "TasksAPI",
+    "AcquisitionsAPI",
+    "PoliciesAPI",
+    "OrganizationsAPI",
+    "TriageAPI",
+    "AuditAPI",
+    "BaselineAPI",
+    "AuthAPI",
+    "EvidenceAPI",
+    "AutoAssetTagsAPI",
+    "EventSubscriptionAPI",
+    "InteractAPI", 
+    "ParamsAPI",
+    "SettingsAPI",
+    "WebhookAPI",
+    "APITokensAPI",
+    "InvestigationHubAPI",
+    "CloudForensicsAPI",
+    "BackupAPI",
+    "LicenseAPI",
+    "LoggerAPI",
+    "MultipartUploadAPI",
+    "NotificationsAPI",
+    "PresetFiltersAPI",
+    "RecentActivitiesAPI",
+    "RelayServerAPI",
+    "WebhookExecutionsAPI",
+    "UserManagementAPI",
+]

binalyze_air/apis/acquisitions.py

@@ -0,0 +1,107 @@
+"""
+Acquisitions API for the Binalyze AIR SDK using CQRS pattern.
+"""
+
+from typing import List, Optional, Dict, Any
+from ..http_client import HTTPClient
+from ..models.acquisitions import (
+    AcquisitionProfile, AcquisitionProfileDetails, AcquisitionFilter,
+    AcquisitionTaskRequest, ImageAcquisitionTaskRequest, CreateAcquisitionProfileRequest
+)
+from ..queries.acquisitions import (
+    ListAcquisitionProfilesQuery,
+    GetAcquisitionProfileQuery,
+)
+from ..commands.acquisitions import (
+    CreateAcquisitionCommand,
+    CreateImageAcquisitionCommand,
+    CreateAcquisitionProfileCommand,
+    AssignAcquisitionTaskCommand,
+    AssignImageAcquisitionTaskCommand,
+    UpdateAcquisitionProfileCommand,
+    DeleteAcquisitionProfileCommand,
+    CreateOffNetworkAcquisitionCommand,
+    UpdateScheduledEvidenceAcquisitionCommand,
+    UpdateScheduledImageAcquisitionCommand,
+    ValidateOsqueryCommand,
+)
+
+
+class AcquisitionsAPI:
+    """Acquisitions API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # QUERIES (Read operations)
+    def list_profiles(
+        self, 
+        filter_params: Optional[AcquisitionFilter] = None,
+        organization_ids: Optional[List[int]] = None,
+        all_organizations: bool = False
+    ) -> List[AcquisitionProfile]:
+        """List acquisition profiles with optional filtering."""
+        query = ListAcquisitionProfilesQuery(self.http_client, filter_params, organization_ids, all_organizations)
+        return query.execute()
+    
+    def get_profile(self, profile_id: str) -> AcquisitionProfileDetails:
+        """Get a specific acquisition profile by ID."""
+        query = GetAcquisitionProfileQuery(self.http_client, profile_id)
+        return query.execute()
+    
+    # COMMANDS (Write operations)
+    def acquire(self, request) -> Dict[str, Any]:
+        """Assign evidence acquisition task by filter."""
+        command = CreateAcquisitionCommand(self.http_client, request)
+        return command.execute()
+    
+    def acquire_image(self, request) -> Dict[str, Any]:
+        """Assign image acquisition task by filter."""
+        command = CreateImageAcquisitionCommand(self.http_client, request)
+        return command.execute()
+    
+    def create_profile(self, request: CreateAcquisitionProfileRequest) -> Dict[str, Any]:
+        """Create acquisition profile."""
+        command = CreateAcquisitionProfileCommand(self.http_client, request)
+        return command.execute()
+
+    def update_profile(self, profile_id: str, request: CreateAcquisitionProfileRequest) -> Dict[str, Any]:
+        """Update acquisition profile by ID."""
+        command = UpdateAcquisitionProfileCommand(self.http_client, profile_id, request)
+        return command.execute()
+    
+    def delete_profile(self, profile_id: str) -> Dict[str, Any]:
+        """Delete acquisition profile by ID."""
+        command = DeleteAcquisitionProfileCommand(self.http_client, profile_id)
+        return command.execute()
+    
+    def acquire_off_network(self, request) -> Dict[str, Any]:
+        """Create evidence acquisition off-network task."""
+        command = CreateOffNetworkAcquisitionCommand(self.http_client, request)
+        return command.execute()
+    
+    def update_scheduled_evidence_acquisition(self, task_id: str, request: Dict[str, Any]) -> Dict[str, Any]:
+        """Update scheduled evidence acquisition."""
+        command = UpdateScheduledEvidenceAcquisitionCommand(self.http_client, task_id, request)
+        return command.execute()
+    
+    def update_scheduled_image_acquisition(self, task_id: str, request: Dict[str, Any]) -> Dict[str, Any]:
+        """Update scheduled image acquisition."""
+        command = UpdateScheduledImageAcquisitionCommand(self.http_client, task_id, request)
+        return command.execute()
+    
+    def validate_osquery(self, request: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Validate osquery."""
+        command = ValidateOsqueryCommand(self.http_client, request)
+        return command.execute()
+
+    # Legacy method aliases for backwards compatibility
+    def assign_task(self, request: AcquisitionTaskRequest) -> List[Dict[str, Any]]:
+        """Legacy alias for acquire method."""
+        command = AssignAcquisitionTaskCommand(self.http_client, request)
+        return command.execute()
+    
+    def assign_image_task(self, request: ImageAcquisitionTaskRequest) -> List[Dict[str, Any]]:
+        """Legacy alias for acquire_image method."""
+        command = AssignImageAcquisitionTaskCommand(self.http_client, request)
+        return command.execute() 

binalyze_air/apis/api_tokens.py

@@ -0,0 +1,49 @@
+"""
+API Tokens API for the Binalyze AIR SDK.
+"""
+
+from typing import Optional, Dict, Any
+
+from ..http_client import HTTPClient
+from ..models.api_tokens import (
+    APIToken, APITokensPaginatedResponse, APITokenFilter,
+    CreateAPITokenRequest, UpdateAPITokenRequest
+)
+from ..queries.api_tokens import ListAPITokensQuery, GetAPITokenQuery
+from ..commands.api_tokens import (
+    CreateAPITokenCommand, UpdateAPITokenCommand, DeleteAPITokenCommand
+)
+
+
+class APITokensAPI:
+    """API Tokens API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # QUERIES (Read operations)
+    def list(self, filter_params: Optional[APITokenFilter] = None) -> APITokensPaginatedResponse:
+        """List API tokens with optional filtering."""
+        query = ListAPITokensQuery(self.http_client, filter_params)
+        return query.execute()
+    
+    def get(self, token_id: str) -> APIToken:
+        """Get a specific API token by ID."""
+        query = GetAPITokenQuery(self.http_client, token_id)
+        return query.execute()
+    
+    # COMMANDS (Write operations)
+    def create(self, request: CreateAPITokenRequest) -> APIToken:
+        """Create a new API token."""
+        command = CreateAPITokenCommand(self.http_client, request)
+        return command.execute()
+    
+    def update(self, token_id: str, request: UpdateAPITokenRequest) -> APIToken:
+        """Update an existing API token."""
+        command = UpdateAPITokenCommand(self.http_client, token_id, request)
+        return command.execute()
+    
+    def delete(self, token_id: str) -> Dict[str, Any]:
+        """Delete an API token."""
+        command = DeleteAPITokenCommand(self.http_client, token_id)
+        return command.execute() 

binalyze_air/apis/assets.py

@@ -0,0 +1,161 @@
+"""
+Assets API for the Binalyze AIR SDK using CQRS pattern.
+"""
+
+from typing import List, Optional, Dict, Any, Union
+from ..http_client import HTTPClient
+from ..models.assets import Asset, AssetDetail, AssetTask, AssetFilter, AssetTaskFilter
+from ..queries.assets import (
+    ListAssetsQuery,
+    GetAssetQuery,
+    GetAssetTasksQuery,
+    GetAssetGroupsByOrganizationIdQuery,
+    GetAssetGroupsByParentIdQuery,
+    GetAssetTagsQuery,
+    GetProcessorsByAssetTypeIdQuery,
+    GetProcessorTypesByAssetTypeQuery,
+)
+from ..commands.assets import (
+    IsolateAssetsCommand,
+    UnisolateAssetsCommand,
+    RebootAssetsCommand,
+    ShutdownAssetsCommand,
+    AddTagsToAssetsCommand,
+    RemoveTagsFromAssetsCommand,
+    UninstallAssetsCommand,
+    LogRetrievalCommand,
+    VersionUpdateCommand,
+    DeleteAssetTagByIdCommand,
+    DeleteAssetTagsByOrganizationIdCommand,
+)
+
+
+class AssetsAPI:
+    """Assets API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # QUERIES (Read operations)
+    def list(self, filter_params: Optional[AssetFilter] = None) -> List[Asset]:
+        """List assets with optional filtering."""
+        query = ListAssetsQuery(self.http_client, filter_params)
+        return query.execute()
+    
+    def get(self, asset_id: str) -> AssetDetail:
+        """Get a specific asset by ID."""
+        query = GetAssetQuery(self.http_client, asset_id)
+        return query.execute()
+    
+    def get_tasks(self, asset_id: str, filter_params: Optional[AssetTaskFilter] = None) -> List[AssetTask]:
+        """Get tasks for a specific asset with optional filtering."""
+        query = GetAssetTasksQuery(self.http_client, asset_id, filter_params)
+        return query.execute()
+    
+    def get_asset_groups_by_organization_id(self, organization_id: int) -> List[Dict[str, Any]]:
+        """Get root asset groups by organization ID."""
+        query = GetAssetGroupsByOrganizationIdQuery(self.http_client, organization_id)
+        return query.execute()
+    
+    def get_asset_groups_by_parent_id(self, group_id: str) -> List[Dict[str, Any]]:
+        """Get asset groups by parent ID."""
+        query = GetAssetGroupsByParentIdQuery(self.http_client, group_id)
+        return query.execute()
+    
+    def get_asset_tags(self, organization_ids: List[int], page_number: int = 1, 
+                      page_size: int = 10, sort_by: str = "createdAt",
+                      search_term: Optional[str] = None) -> Dict[str, Any]:
+        """Get asset tags with filtering."""
+        query = GetAssetTagsQuery(self.http_client, organization_ids, page_number, 
+                                page_size, sort_by, search_term)
+        return query.execute()
+    
+    def get_processors_by_asset_type_id(self, asset_type_id: int) -> List[Dict[str, Any]]:
+        """Get processors by asset type ID."""
+        query = GetProcessorsByAssetTypeIdQuery(self.http_client, asset_type_id)
+        return query.execute()
+    
+    def get_processor_types_by_asset_type(self, asset_type_id: int) -> Dict[str, Any]:
+        """Get processor types by asset type ID."""
+        query = GetProcessorTypesByAssetTypeQuery(self.http_client, asset_type_id)
+        return query.execute()
+    
+    # COMMANDS (Write operations)
+    def isolate(self, endpoint_ids: Union[str, List[str]], organization_ids: Optional[List[Union[int, str]]] = None) -> Dict[str, Any]:
+        """Isolate one or more assets."""
+        # Create AssetFilter from endpoint IDs for backward compatibility
+        from ..commands.assets import create_asset_filter_from_endpoint_ids
+        asset_filter = create_asset_filter_from_endpoint_ids(endpoint_ids, organization_ids)
+        command = IsolateAssetsCommand(self.http_client, asset_filter)
+        return command.execute()
+    
+    def unisolate(self, endpoint_ids: Union[str, List[str]], organization_ids: Optional[List[Union[int, str]]] = None) -> Dict[str, Any]:
+        """Remove isolation from one or more assets."""
+        from ..commands.assets import create_asset_filter_from_endpoint_ids
+        asset_filter = create_asset_filter_from_endpoint_ids(endpoint_ids, organization_ids)
+        command = UnisolateAssetsCommand(self.http_client, asset_filter)
+        return command.execute()
+    
+    def reboot(self, endpoint_ids: Union[str, List[str]], organization_ids: Optional[List[Union[int, str]]] = None) -> Dict[str, Any]:
+        """Reboot one or more assets."""
+        from ..commands.assets import create_asset_filter_from_endpoint_ids
+        asset_filter = create_asset_filter_from_endpoint_ids(endpoint_ids, organization_ids)
+        command = RebootAssetsCommand(self.http_client, asset_filter)
+        return command.execute()
+    
+    def shutdown(self, endpoint_ids: Union[str, List[str]], organization_ids: Optional[List[Union[int, str]]] = None) -> Dict[str, Any]:
+        """Shutdown one or more assets."""
+        from ..commands.assets import create_asset_filter_from_endpoint_ids
+        asset_filter = create_asset_filter_from_endpoint_ids(endpoint_ids, organization_ids)
+        command = ShutdownAssetsCommand(self.http_client, asset_filter)
+        return command.execute()
+    
+    def add_tags(self, endpoint_ids: List[str], tags: List[str], organization_ids: Optional[List[Union[int, str]]] = None) -> Dict[str, Any]:
+        """Add tags to assets."""
+        from ..commands.assets import create_asset_filter_from_endpoint_ids
+        asset_filter = create_asset_filter_from_endpoint_ids(endpoint_ids, organization_ids)
+        command = AddTagsToAssetsCommand(self.http_client, asset_filter, tags)
+        return command.execute()
+    
+    def remove_tags(self, endpoint_ids: List[str], tags: List[str], organization_ids: Optional[List[Union[int, str]]] = None) -> Dict[str, Any]:
+        """Remove tags from assets."""
+        from ..commands.assets import create_asset_filter_from_endpoint_ids
+        asset_filter = create_asset_filter_from_endpoint_ids(endpoint_ids, organization_ids)
+        command = RemoveTagsFromAssetsCommand(self.http_client, asset_filter, tags)
+        return command.execute()
+    
+    def delete_asset_tag_by_id(self, organization_id: int, tag_id: str) -> Dict[str, Any]:
+        """Delete an asset tag by ID."""
+        command = DeleteAssetTagByIdCommand(self.http_client, organization_id, tag_id)
+        return command.execute()
+    
+    def delete_asset_tags_by_organization_id(self, organization_id: int) -> Dict[str, Any]:
+        """Delete asset tags by organization ID."""
+        command = DeleteAssetTagsByOrganizationIdCommand(self.http_client, organization_id)
+        return command.execute()
+    
+    def uninstall(self, endpoint_ids: List[str], purge_data: bool = False, organization_ids: Optional[List[Union[int, str]]] = None) -> Dict[str, Any]:
+        """Uninstall assets with optional data purging."""
+        from ..commands.assets import create_asset_filter_from_endpoint_ids
+        asset_filter = create_asset_filter_from_endpoint_ids(endpoint_ids, organization_ids)
+        if purge_data:
+            from ..commands.assets import PurgeAndUninstallAssetsCommand
+            command = PurgeAndUninstallAssetsCommand(self.http_client, asset_filter)
+        else:
+            from ..commands.assets import UninstallAssetsCommand
+            command = UninstallAssetsCommand(self.http_client, asset_filter)
+        return command.execute()
+    
+    def retrieve_logs(self, endpoint_ids: List[str], organization_ids: Optional[List[Union[int, str]]] = None) -> Dict[str, Any]:
+        """Retrieve logs from assets."""
+        from ..commands.assets import create_asset_filter_from_endpoint_ids
+        asset_filter = create_asset_filter_from_endpoint_ids(endpoint_ids, organization_ids)
+        command = LogRetrievalCommand(self.http_client, asset_filter)
+        return command.execute()
+    
+    def version_update(self, endpoint_ids: List[str], organization_ids: Optional[List[Union[int, str]]] = None) -> Dict[str, Any]:
+        """Update version on assets."""
+        from ..commands.assets import create_asset_filter_from_endpoint_ids
+        asset_filter = create_asset_filter_from_endpoint_ids(endpoint_ids, organization_ids)
+        command = VersionUpdateCommand(self.http_client, asset_filter)
+        return command.execute() 

binalyze_air/apis/audit_logs.py

@@ -0,0 +1,26 @@
+"""
+Audit Logs API for the Binalyze AIR SDK using CQRS pattern.
+"""
+
+from typing import List, Optional, Dict, Any
+from ..http_client import HTTPClient
+from ..models.audit import AuditLog, AuditLogsFilter
+from ..queries.audit import ListAuditLogsQuery, ExportAuditLogsQuery
+
+
+class AuditAPI:
+    """Audit logs API aligned with official API specification."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # QUERIES (Read operations)
+    def list_logs(self, filter_params: Optional[AuditLogsFilter] = None, organization_ids: Optional[int] = None) -> List[AuditLog]:
+        """List audit logs with filtering - Official API endpoint."""
+        query = ListAuditLogsQuery(self.http_client, filter_params, organization_ids)
+        return query.execute()
+    
+    def export_logs(self, filter_params: Optional[AuditLogsFilter] = None, format: str = "json", organization_ids: Optional[int] = None) -> Dict[str, Any]:
+        """Export audit logs with filtering - Official API endpoint."""
+        query = ExportAuditLogsQuery(self.http_client, filter_params, format, organization_ids)
+        return query.execute() 

binalyze_air/apis/{authentication.py → auth.py}

@@ -1,27 +1,29 @@
-"""
-Authentication API for the Binalyze AIR SDK.
-"""
-
-from ..http_client import HTTPClient
-from ..models.authentication import AuthStatus, LoginRequest, LoginResponse
-from ..queries.authentication import CheckAuthStatusQuery
-from ..commands.authentication import LoginCommand
-
-
-class AuthenticationAPI:
-    """Authentication API with CQRS pattern - separated queries and commands."""
-
-    def __init__(self, http_client: HTTPClient):
-        self.http_client = http_client
-
-    # QUERIES (Read operations)
-    def check_status(self) -> AuthStatus:
-        """Check current authentication status."""
-        query = CheckAuthStatusQuery(self.http_client)
-        return query.execute()
-
-    # COMMANDS (Write operations)
-    def login(self, request: LoginRequest) -> LoginResponse:
-        """Login user with credentials."""
-        command = LoginCommand(self.http_client, request)
-        return command.execute()
+"""
+Auth API for the Binalyze AIR SDK.
+"""
+
+from typing import Dict, Any, Union
+
+from ..http_client import HTTPClient
+from ..models.auth import AuthStatus, LoginRequest, LoginResponse
+from ..queries.auth import CheckAuthStatusQuery
+from ..commands.auth import LoginCommand
+
+
+class AuthAPI:
+    """Auth API with CQRS pattern - separated queries and commands."""
+
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+
+    # QUERIES (Read operations)
+    def check_status(self) -> AuthStatus:
+        """Check current authentication status."""
+        query = CheckAuthStatusQuery(self.http_client)
+        return query.execute()
+
+    # COMMANDS (Write operations)
+    def login(self, request: Union[LoginRequest, Dict[str, Any]]) -> LoginResponse:
+        """Login user with credentials."""
+        command = LoginCommand(self.http_client, request)
+        return command.execute()