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

binalyze_air/apis/cloud_forensics.py

@@ -0,0 +1,116 @@
+"""
+Cloud Forensics API for the Binalyze AIR SDK.
+"""
+
+from typing import Optional, Dict, Any
+
+from ..http_client import HTTPClient
+from ..models.cloud_forensics import (
+    CloudAccount, CloudAccountsPaginatedResponse, CloudAccountFilter,
+    CreateCloudAccountRequest, UpdateCloudAccountRequest, CloudAccountSyncResult,
+    CloudVendorSyncResult, CloudVendor
+)
+from ..queries.cloud_forensics import (
+    ListCloudAccountsQuery, GetCloudAccountQuery, ExportCloudAccountsQuery,
+    SyncCloudAccountQuery, SyncCloudAccountsByVendorQuery
+)
+from ..commands.cloud_forensics import (
+    CreateCloudAccountCommand, UpdateCloudAccountCommand, DeleteCloudAccountCommand
+)
+
+
+class CloudForensicsAPI:
+    """Cloud Forensics API with CQRS pattern - separated queries and commands."""
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # QUERIES (Read operations)
+    def list_accounts(self, filter_params: Optional[CloudAccountFilter] = None) -> CloudAccountsPaginatedResponse:
+        """List cloud accounts with optional filtering."""
+        query = ListCloudAccountsQuery(self.http_client, filter_params)
+        return query.execute()
+    
+    def get_account(self, account_id: str) -> CloudAccount:
+        """Get a specific cloud account by ID."""
+        query = GetCloudAccountQuery(self.http_client, account_id)
+        return query.execute()
+    
+    def export_accounts(self, filter_params: Optional[CloudAccountFilter] = None) -> Dict[str, Any]:
+        """Export cloud accounts data."""
+        query = ExportCloudAccountsQuery(self.http_client, filter_params)
+        return query.execute()
+    
+    def sync_account(self, account_id: str) -> CloudAccountSyncResult:
+        """Sync a specific cloud account by ID."""
+        query = SyncCloudAccountQuery(self.http_client, account_id)
+        return query.execute()
+    
+    def sync_accounts_by_vendor(self, cloud_vendor: CloudVendor) -> CloudVendorSyncResult:
+        """Sync all cloud accounts by vendor."""
+        query = SyncCloudAccountsByVendorQuery(self.http_client, cloud_vendor)
+        return query.execute()
+    
+    # COMMANDS (Write operations)
+    def create_account(self, request: CreateCloudAccountRequest) -> CloudAccount:
+        """Create a new cloud account."""
+        command = CreateCloudAccountCommand(self.http_client, request)
+        return command.execute()
+    
+    def update_account(self, account_id: str, request: UpdateCloudAccountRequest) -> CloudAccount:
+        """Update an existing cloud account."""
+        command = UpdateCloudAccountCommand(self.http_client, account_id, request)
+        return command.execute()
+    
+    def delete_account(self, account_id: str) -> Dict[str, Any]:
+        """Delete a cloud account."""
+        command = DeleteCloudAccountCommand(self.http_client, account_id)
+        return command.execute()
+    
+    # Convenience methods
+    def list_aws_accounts(self, filter_params: Optional[CloudAccountFilter] = None) -> CloudAccountsPaginatedResponse:
+        """List AWS cloud accounts."""
+        if filter_params is None:
+            filter_params = CloudAccountFilter()
+        filter_params.cloud_vendor = CloudVendor.AWS
+        return self.list_accounts(filter_params)
+    
+    def list_azure_accounts(self, filter_params: Optional[CloudAccountFilter] = None) -> CloudAccountsPaginatedResponse:
+        """List Azure cloud accounts."""
+        if filter_params is None:
+            filter_params = CloudAccountFilter()
+        filter_params.cloud_vendor = CloudVendor.AZURE
+        return self.list_accounts(filter_params)
+    
+    def sync_all_aws_accounts(self) -> CloudVendorSyncResult:
+        """Sync all AWS accounts."""
+        return self.sync_accounts_by_vendor(CloudVendor.AWS)
+    
+    def sync_all_azure_accounts(self) -> CloudVendorSyncResult:
+        """Sync all Azure accounts."""
+        return self.sync_accounts_by_vendor(CloudVendor.AZURE)
+    
+    def get_account_summary(self, filter_params: Optional[CloudAccountFilter] = None) -> Dict[str, Any]:
+        """Get a summary of cloud accounts including counts by vendor and status."""
+        accounts = self.list_accounts(filter_params)
+        
+        summary = {
+            "total_accounts": len(accounts.entities),
+            "by_vendor": {},
+            "by_status": {},
+            "total_assets": 0
+        }
+        
+        for account in accounts.entities:
+            # Count by vendor (handle both enum and string cases)
+            vendor = account.cloud_vendor.value if hasattr(account.cloud_vendor, 'value') else str(account.cloud_vendor)
+            summary["by_vendor"][vendor] = summary["by_vendor"].get(vendor, 0) + 1
+            
+            # Count by status (handle both enum and string cases)
+            status = account.status.value if hasattr(account.status, 'value') else str(account.status)
+            summary["by_status"][status] = summary["by_status"].get(status, 0) + 1
+            
+            # Sum total assets
+            summary["total_assets"] += account.detected_assets_count
+        
+        return summary 

binalyze_air/apis/event_subscription.py

@@ -1,97 +1,97 @@
-"""
-Event Subscription API for the Binalyze AIR SDK.
-"""
-
-from typing import List, Optional, Dict, Any, Union
-
-from ..http_client import HTTPClient
-from ..models.event_subscription import (
-    EventSubscription, EventSubscriptionFilter, 
-    CreateEventSubscriptionRequest, UpdateEventSubscriptionRequest
-)
-from ..queries.event_subscription import ListEventSubscriptionsQuery, GetEventSubscriptionQuery
-from ..commands.event_subscription import (
-    CreateEventSubscriptionCommand, UpdateEventSubscriptionCommand, DeleteEventSubscriptionCommand
-)
-
-
-class EventSubscriptionAPI:
-    """Event Subscription 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[EventSubscriptionFilter] = None) -> List[EventSubscription]:
-        """List event subscriptions with optional filtering."""
-        query = ListEventSubscriptionsQuery(self.http_client, filter_params)
-        return query.execute()
-    
-    def get(self, subscription_id: str) -> EventSubscription:
-        """Get a specific event subscription by ID."""
-        query = GetEventSubscriptionQuery(self.http_client, subscription_id)
-        return query.execute()
-    
-    # Webhook-specific aliases for queries
-    def list_webhooks(self, filter_params: Optional[EventSubscriptionFilter] = None) -> List[EventSubscription]:
-        """List webhooks - alias for list."""
-        return self.list(filter_params)
-    
-    def get_webhook(self, webhook_id: str) -> EventSubscription:
-        """Get a specific webhook by ID - alias for get."""
-        return self.get(webhook_id)
-    
-    def get_webhook_events(self, webhook_id: str) -> List[Dict[str, Any]]:
-        """Get webhook events."""
-        try:
-            # This would typically get events for a specific webhook
-            response = self.http_client.get(f"event-subscriptions/{webhook_id}/events")
-            return response.get("result", [])
-        except Exception as e:
-            # Return a simulated response for testing
-            return [
-                {"event": "asset.created", "timestamp": "2024-01-01T00:00:00Z"},
-                {"event": "case.updated", "timestamp": "2024-01-01T00:01:00Z"}
-            ]
-    
-    # COMMANDS (Write operations)
-    def create(self, request: Union[CreateEventSubscriptionRequest, Dict[str, Any]]) -> EventSubscription:
-        """Create a new event subscription."""
-        command = CreateEventSubscriptionCommand(self.http_client, request)
-        return command.execute()
-    
-    def update(self, subscription_id: str, request: Union[UpdateEventSubscriptionRequest, Dict[str, Any]]) -> EventSubscription:
-        """Update an existing event subscription."""
-        command = UpdateEventSubscriptionCommand(self.http_client, subscription_id, request)
-        return command.execute()
-    
-    def delete(self, subscription_id: str) -> Dict[str, Any]:
-        """Delete an event subscription."""
-        command = DeleteEventSubscriptionCommand(self.http_client, subscription_id)
-        return command.execute()
-    
-    # Webhook-specific aliases for commands
-    def create_webhook(self, webhook_data: Union[CreateEventSubscriptionRequest, Dict[str, Any]]) -> EventSubscription:
-        """Create a new webhook - alias for create."""
-        return self.create(webhook_data)
-    
-    def update_webhook(self, webhook_id: str, update_data: Union[UpdateEventSubscriptionRequest, Dict[str, Any]]) -> EventSubscription:
-        """Update an existing webhook - alias for update."""
-        return self.update(webhook_id, update_data)
-    
-    def delete_webhook(self, webhook_id: str) -> Dict[str, Any]:
-        """Delete a webhook - alias for delete."""
-        return self.delete(webhook_id)
-    
-    def test_webhook(self, webhook_id: str) -> Dict[str, Any]:
-        """Test webhook connectivity."""
-        try:
-            response = self.http_client.post(f"event-subscriptions/{webhook_id}/test", json_data={})
-            return response
-        except Exception as e:
-            # Return a simulated response for testing
-            return {
-                "success": False,
-                "error": str(e),
-                "test_result": "failed"
+"""
+Event Subscription API for the Binalyze AIR SDK.
+"""
+
+from typing import List, Optional, Dict, Any, Union
+
+from ..http_client import HTTPClient
+from ..models.event_subscription import (
+    EventSubscription, EventSubscriptionFilter, 
+    CreateEventSubscriptionRequest, UpdateEventSubscriptionRequest
+)
+from ..queries.event_subscription import ListEventSubscriptionsQuery, GetEventSubscriptionQuery
+from ..commands.event_subscription import (
+    CreateEventSubscriptionCommand, UpdateEventSubscriptionCommand, DeleteEventSubscriptionCommand
+)
+
+
+class EventSubscriptionAPI:
+    """Event Subscription 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[EventSubscriptionFilter] = None) -> List[EventSubscription]:
+        """List event subscriptions with optional filtering."""
+        query = ListEventSubscriptionsQuery(self.http_client, filter_params)
+        return query.execute()
+    
+    def get(self, subscription_id: str) -> EventSubscription:
+        """Get a specific event subscription by ID."""
+        query = GetEventSubscriptionQuery(self.http_client, subscription_id)
+        return query.execute()
+    
+    # Webhook-specific aliases for queries
+    def list_webhooks(self, filter_params: Optional[EventSubscriptionFilter] = None) -> List[EventSubscription]:
+        """List webhooks - alias for list."""
+        return self.list(filter_params)
+    
+    def get_webhook(self, webhook_id: str) -> EventSubscription:
+        """Get a specific webhook by ID - alias for get."""
+        return self.get(webhook_id)
+    
+    def get_webhook_events(self, webhook_id: str) -> List[Dict[str, Any]]:
+        """Get webhook events."""
+        try:
+            # This would typically get events for a specific webhook
+            response = self.http_client.get(f"event-subscriptions/{webhook_id}/events")
+            return response.get("result", [])
+        except Exception as e:
+            # Return a simulated response for testing
+            return [
+                {"event": "asset.created", "timestamp": "2024-01-01T00:00:00Z"},
+                {"event": "case.updated", "timestamp": "2024-01-01T00:01:00Z"}
+            ]
+    
+    # COMMANDS (Write operations)
+    def create(self, request: Union[CreateEventSubscriptionRequest, Dict[str, Any]]) -> EventSubscription:
+        """Create a new event subscription."""
+        command = CreateEventSubscriptionCommand(self.http_client, request)
+        return command.execute()
+    
+    def update(self, subscription_id: str, request: Union[UpdateEventSubscriptionRequest, Dict[str, Any]]) -> EventSubscription:
+        """Update an existing event subscription."""
+        command = UpdateEventSubscriptionCommand(self.http_client, subscription_id, request)
+        return command.execute()
+    
+    def delete(self, subscription_id: str) -> Dict[str, Any]:
+        """Delete an event subscription."""
+        command = DeleteEventSubscriptionCommand(self.http_client, subscription_id)
+        return command.execute()
+    
+    # Webhook-specific aliases for commands
+    def create_webhook(self, webhook_data: Union[CreateEventSubscriptionRequest, Dict[str, Any]]) -> EventSubscription:
+        """Create a new webhook - alias for create."""
+        return self.create(webhook_data)
+    
+    def update_webhook(self, webhook_id: str, update_data: Union[UpdateEventSubscriptionRequest, Dict[str, Any]]) -> EventSubscription:
+        """Update an existing webhook - alias for update."""
+        return self.update(webhook_id, update_data)
+    
+    def delete_webhook(self, webhook_id: str) -> Dict[str, Any]:
+        """Delete a webhook - alias for delete."""
+        return self.delete(webhook_id)
+    
+    def test_webhook(self, webhook_id: str) -> Dict[str, Any]:
+        """Test webhook connectivity."""
+        try:
+            response = self.http_client.post(f"event-subscriptions/{webhook_id}/test", json_data={})
+            return response
+        except Exception as e:
+            # Return a simulated response for testing
+            return {
+                "success": False,
+                "error": str(e),
+                "test_result": "failed"
             } 

binalyze_air/apis/evidence.py

@@ -1,53 +1,249 @@
-"""
-Evidence API for the Binalyze AIR SDK.
-"""
-
-from typing import List, Dict, Any
-
-from ..http_client import HTTPClient
-from ..models.evidence import EvidencePPC, EvidenceReportFileInfo, EvidenceReport
-from ..queries.evidence import (
-    GetEvidencePPCQuery, GetEvidenceReportFileInfoQuery, GetEvidenceReportQuery
-)
-
-
-class EvidenceAPI:
-    """Evidence API with CQRS pattern - read-only operations for case evidence."""
-    
-    def __init__(self, http_client: HTTPClient):
-        self.http_client = http_client
-    
-    # QUERIES (Read operations only - evidence is read-only)
-    def get_case_evidence_ppc(self, endpoint_id: str, task_id: str) -> EvidencePPC:
-        """Get case evidence PPC by endpoint ID and task ID."""
-        query = GetEvidencePPCQuery(self.http_client, endpoint_id, task_id)
-        return query.execute()
-    
-    def get_case_evidence_report_file_info(self, endpoint_id: str, task_id: str) -> EvidenceReportFileInfo:
-        """Get case evidence report file info by endpoint ID and task ID."""
-        query = GetEvidenceReportFileInfoQuery(self.http_client, endpoint_id, task_id)
-        return query.execute()
-    
-    def get_case_evidence_report(self, endpoint_id: str, task_id: str) -> EvidenceReport:
-        """Get case evidence report by endpoint ID and task ID."""
-        query = GetEvidenceReportQuery(self.http_client, endpoint_id, task_id)
-        return query.execute()
-    
-    # REPOSITORY OPERATIONS (Delegate to evidences API for backward compatibility)
-    def list_repositories(self) -> List[Any]:
-        """List evidence repositories - delegates to evidences API."""
-        from .evidences import EvidencesAPI
-        evidences_api = EvidencesAPI(self.http_client)
-        return evidences_api.list_repositories()
-    
-    def get_repository(self, repository_id: str) -> Any:
-        """Get repository details - delegates to evidences API."""
-        from .evidences import EvidencesAPI
-        evidences_api = EvidencesAPI(self.http_client)
-        return evidences_api.get_repository(repository_id)
-    
-    def get_repository_statistics(self, repository_id: str) -> Dict[str, Any]:
-        """Get repository statistics - delegates to evidences API."""
-        from .evidences import EvidencesAPI
-        evidences_api = EvidencesAPI(self.http_client)
-        return evidences_api.get_repository_statistics(repository_id) 
+"""
+Evidence API for the Binalyze AIR SDK.
+Comprehensive API covering all evidence operations including case evidence and evidence repositories.
+"""
+
+from typing import List, Optional, Dict, Any
+
+from ..http_client import HTTPClient
+from ..models.evidence import EvidencePPC, EvidenceReportFileInfo, EvidenceReport
+from ..models.evidences import (
+    EvidenceRepository, AmazonS3Repository, AzureStorageRepository,
+    FTPSRepository, SFTPRepository, SMBRepository, RepositoryFilter,
+    CreateAmazonS3RepositoryRequest, UpdateAmazonS3RepositoryRequest,
+    CreateAzureStorageRepositoryRequest, UpdateAzureStorageRepositoryRequest,
+    CreateFTPSRepositoryRequest, UpdateFTPSRepositoryRequest,
+    CreateSFTPRepositoryRequest, UpdateSFTPRepositoryRequest,
+    CreateSMBRepositoryRequest, UpdateSMBRepositoryRequest,
+    ValidateRepositoryRequest, ValidationResult
+)
+from ..queries.evidence import (
+    GetEvidencePPCQuery, GetEvidenceReportFileInfoQuery, GetEvidenceReportQuery
+)
+from ..queries.evidences import (
+    ListRepositoriesQuery, GetRepositoryQuery,
+    ListAmazonS3RepositoriesQuery, GetAmazonS3RepositoryQuery,
+    ListAzureStorageRepositoriesQuery, GetAzureStorageRepositoryQuery,
+    ListFTPSRepositoriesQuery, GetFTPSRepositoryQuery,
+    ListSFTPRepositoriesQuery, GetSFTPRepositoryQuery,
+    ListSMBRepositoriesQuery, GetSMBRepositoryQuery
+)
+from ..commands.evidences import (
+    UpdateRepositoryCommand, DeleteRepositoryCommand,
+    CreateAmazonS3RepositoryCommand, UpdateAmazonS3RepositoryCommand,
+    ValidateAmazonS3RepositoryCommand,
+    CreateAzureStorageRepositoryCommand, UpdateAzureStorageRepositoryCommand,
+    ValidateAzureStorageRepositoryCommand,
+    CreateFTPSRepositoryCommand, UpdateFTPSRepositoryCommand,
+    ValidateFTPSRepositoryCommand,
+    CreateSFTPRepositoryCommand, UpdateSFTPRepositoryCommand,
+    CreateSMBRepositoryCommand, UpdateSMBRepositoryCommand
+)
+
+
+class EvidenceAPI:
+    """
+    Comprehensive Evidence API covering all evidence operations.
+    
+    Handles both:
+    1. Case Evidence Operations (/evidence/case/*)
+    2. Evidence Repository Management (/evidences/repositories/*)
+    """
+    
+    def __init__(self, http_client: HTTPClient):
+        self.http_client = http_client
+    
+    # ========================================
+    # CASE EVIDENCE OPERATIONS
+    # ========================================
+    
+    def get_case_evidence_ppc(self, endpoint_id: str, task_id: str) -> EvidencePPC:
+        """Get case evidence PPC by endpoint ID and task ID."""
+        query = GetEvidencePPCQuery(self.http_client, endpoint_id, task_id)
+        return query.execute()
+    
+    def get_case_evidence_report_file_info(self, endpoint_id: str, task_id: str) -> EvidenceReportFileInfo:
+        """Get case evidence report file info by endpoint ID and task ID."""
+        query = GetEvidenceReportFileInfoQuery(self.http_client, endpoint_id, task_id)
+        return query.execute()
+    
+    def get_case_evidence_report(self, endpoint_id: str, task_id: str) -> EvidenceReport:
+        """Get case evidence report by endpoint ID and task ID."""
+        query = GetEvidenceReportQuery(self.http_client, endpoint_id, task_id)
+        return query.execute()
+    
+    # ========================================
+    # EVIDENCE REPOSITORY OPERATIONS
+    # ========================================
+    
+    # GENERAL REPOSITORY QUERIES
+    def list_repositories(self, filter_params: Optional[RepositoryFilter] = None, organization_ids: Optional[List[int]] = None) -> List[EvidenceRepository]:
+        """List evidence repositories with optional filtering."""
+        query = ListRepositoriesQuery(self.http_client, filter_params, organization_ids)
+        return query.execute()
+    
+    def get_repository(self, repository_id: str) -> EvidenceRepository:
+        """Get a specific evidence repository by ID."""
+        query = GetRepositoryQuery(self.http_client, repository_id)
+        return query.execute()
+    
+    def get_repository_statistics(self, repository_id: str) -> Dict[str, Any]:
+        """Get statistics for a specific evidence repository."""
+        response = self.http_client.get(f"repositories/{repository_id}/statistics")
+        return response.get("result", {})
+    
+    # GENERAL REPOSITORY COMMANDS
+    def update_repository(self, repository_id: str, update_data: Dict[str, Any]) -> EvidenceRepository:
+        """Update an evidence repository."""
+        command = UpdateRepositoryCommand(self.http_client, repository_id, update_data)
+        return command.execute()
+    
+    def delete_repository(self, repository_id: str) -> Dict[str, Any]:
+        """Delete an evidence repository."""
+        command = DeleteRepositoryCommand(self.http_client, repository_id)
+        return command.execute()
+    
+    # AMAZON S3 REPOSITORY OPERATIONS
+    def list_amazon_s3_repositories(self, filter_params: Optional[RepositoryFilter] = None) -> List[AmazonS3Repository]:
+        """List Amazon S3 repositories with optional filtering."""
+        query = ListAmazonS3RepositoriesQuery(self.http_client, filter_params)
+        return query.execute()
+    
+    def get_amazon_s3_repository(self, repository_id: str) -> AmazonS3Repository:
+        """Get a specific Amazon S3 repository by ID."""
+        query = GetAmazonS3RepositoryQuery(self.http_client, repository_id)
+        return query.execute()
+    
+    def create_amazon_s3_repository(self, request: CreateAmazonS3RepositoryRequest) -> AmazonS3Repository:
+        """Create a new Amazon S3 repository."""
+        command = CreateAmazonS3RepositoryCommand(self.http_client, request)
+        return command.execute()
+    
+    def update_amazon_s3_repository(self, repository_id: str, request: UpdateAmazonS3RepositoryRequest) -> AmazonS3Repository:
+        """Update an existing Amazon S3 repository."""
+        command = UpdateAmazonS3RepositoryCommand(self.http_client, repository_id, request)
+        return command.execute()
+    
+    def delete_amazon_s3_repository(self, repository_id: str) -> Dict[str, Any]:
+        """Delete an Amazon S3 repository."""
+        command = DeleteRepositoryCommand(self.http_client, repository_id)
+        return command.execute()
+    
+    def validate_amazon_s3_repository(self, request: ValidateRepositoryRequest) -> ValidationResult:
+        """Validate Amazon S3 repository configuration."""
+        command = ValidateAmazonS3RepositoryCommand(self.http_client, request)
+        return command.execute()
+    
+    # AZURE STORAGE REPOSITORY OPERATIONS
+    def list_azure_storage_repositories(self, filter_params: Optional[RepositoryFilter] = None) -> List[AzureStorageRepository]:
+        """List Azure Storage repositories with optional filtering."""
+        query = ListAzureStorageRepositoriesQuery(self.http_client, filter_params)
+        return query.execute()
+    
+    def get_azure_storage_repository(self, repository_id: str) -> AzureStorageRepository:
+        """Get a specific Azure Storage repository by ID."""
+        query = GetAzureStorageRepositoryQuery(self.http_client, repository_id)
+        return query.execute()
+    
+    def create_azure_storage_repository(self, request: CreateAzureStorageRepositoryRequest) -> AzureStorageRepository:
+        """Create a new Azure Storage repository."""
+        command = CreateAzureStorageRepositoryCommand(self.http_client, request)
+        return command.execute()
+    
+    def update_azure_storage_repository(self, repository_id: str, request: UpdateAzureStorageRepositoryRequest) -> AzureStorageRepository:
+        """Update an existing Azure Storage repository."""
+        command = UpdateAzureStorageRepositoryCommand(self.http_client, repository_id, request)
+        return command.execute()
+    
+    def delete_azure_storage_repository(self, repository_id: str) -> Dict[str, Any]:
+        """Delete an Azure Storage repository."""
+        command = DeleteRepositoryCommand(self.http_client, repository_id)
+        return command.execute()
+    
+    def validate_azure_storage_repository(self, request: ValidateRepositoryRequest) -> ValidationResult:
+        """Validate Azure Storage repository configuration."""
+        command = ValidateAzureStorageRepositoryCommand(self.http_client, request)
+        return command.execute()
+
+    # FTPS REPOSITORY OPERATIONS
+    def list_ftps_repositories(self, filter_params: Optional[RepositoryFilter] = None) -> List[FTPSRepository]:
+        """List FTPS repositories with optional filtering."""
+        query = ListFTPSRepositoriesQuery(self.http_client, filter_params)
+        return query.execute()
+
+    def get_ftps_repository(self, repository_id: str) -> FTPSRepository:
+        """Get a specific FTPS repository by ID."""
+        query = GetFTPSRepositoryQuery(self.http_client, repository_id)
+        return query.execute()
+
+    def create_ftps_repository(self, request: CreateFTPSRepositoryRequest) -> FTPSRepository:
+        """Create a new FTPS repository."""
+        command = CreateFTPSRepositoryCommand(self.http_client, request)
+        return command.execute()
+
+    def update_ftps_repository(self, repository_id: str, request: UpdateFTPSRepositoryRequest) -> FTPSRepository:
+        """Update an existing FTPS repository."""
+        command = UpdateFTPSRepositoryCommand(self.http_client, repository_id, request)
+        return command.execute()
+
+    def delete_ftps_repository(self, repository_id: str) -> Dict[str, Any]:
+        """Delete an FTPS repository."""
+        command = DeleteRepositoryCommand(self.http_client, repository_id)
+        return command.execute()
+
+    def validate_ftps_repository(self, request: ValidateRepositoryRequest) -> ValidationResult:
+        """Validate FTPS repository configuration."""
+        command = ValidateFTPSRepositoryCommand(self.http_client, request)
+        return command.execute()
+
+    # SFTP REPOSITORY OPERATIONS
+    def list_sftp_repositories(self, filter_params: Optional[RepositoryFilter] = None) -> List[SFTPRepository]:
+        """List SFTP repositories with optional filtering."""
+        query = ListSFTPRepositoriesQuery(self.http_client, filter_params)
+        return query.execute()
+
+    def get_sftp_repository(self, repository_id: str) -> SFTPRepository:
+        """Get a specific SFTP repository by ID."""
+        query = GetSFTPRepositoryQuery(self.http_client, repository_id)
+        return query.execute()
+
+    def create_sftp_repository(self, request: CreateSFTPRepositoryRequest) -> SFTPRepository:
+        """Create a new SFTP repository."""
+        command = CreateSFTPRepositoryCommand(self.http_client, request)
+        return command.execute()
+
+    def update_sftp_repository(self, repository_id: str, request: UpdateSFTPRepositoryRequest) -> SFTPRepository:
+        """Update an existing SFTP repository."""
+        command = UpdateSFTPRepositoryCommand(self.http_client, repository_id, request)
+        return command.execute()
+
+    def delete_sftp_repository(self, repository_id: str) -> Dict[str, Any]:
+        """Delete an SFTP repository."""
+        command = DeleteRepositoryCommand(self.http_client, repository_id)
+        return command.execute()
+
+    # SMB REPOSITORY OPERATIONS
+    def list_smb_repositories(self, filter_params: Optional[RepositoryFilter] = None) -> List[SMBRepository]:
+        """List SMB repositories with optional filtering."""
+        query = ListSMBRepositoriesQuery(self.http_client, filter_params)
+        return query.execute()
+
+    def get_smb_repository(self, repository_id: str) -> SMBRepository:
+        """Get a specific SMB repository by ID."""
+        query = GetSMBRepositoryQuery(self.http_client, repository_id)
+        return query.execute()
+
+    def create_smb_repository(self, request: CreateSMBRepositoryRequest) -> SMBRepository:
+        """Create a new SMB repository."""
+        command = CreateSMBRepositoryCommand(self.http_client, request)
+        return command.execute()
+
+    def update_smb_repository(self, repository_id: str, request: UpdateSMBRepositoryRequest) -> SMBRepository:
+        """Update an existing SMB repository."""
+        command = UpdateSMBRepositoryCommand(self.http_client, repository_id, request)
+        return command.execute()
+
+    def delete_smb_repository(self, repository_id: str) -> Dict[str, Any]:
+        """Delete an SMB repository."""
+        command = DeleteRepositoryCommand(self.http_client, repository_id)
+        return command.execute()