import json
import logging
from dataclasses import asdict
from typing import Any, Dict, List, Mapping, Optional
import urllib.parse
from kiota_abstractions.base_request_configuration import (  # type: ignore
    RequestConfiguration,
)
from kiota_abstractions.request_information import RequestInformation  # type: ignore
from kiota_abstractions.method import Method  # type: ignore

# Import MS Graph specific query parameter classes
from msgraph.generated.drives.drives_request_builder import (  # type: ignore
    DrivesRequestBuilder,
)
from msgraph.generated.users.item.drive.drive_request_builder import (  # type: ignore
    DriveRequestBuilder,
)
from msgraph.generated.models.item_reference import ItemReference
from app.sources.client.microsoft.microsoft import MSGraphClient
from msgraph.generated.drives.item.recent.recent_request_builder import RecentRequestBuilder
from msgraph.generated.drives.item.items.item.copy.copy_post_request_body import CopyPostRequestBody
from msgraph.generated.drives.item.items.item.drive_item_item_request_builder import DriveItemItemRequestBuilder
from msgraph.generated.models.drive_item import DriveItem as DriveItemModel
from msgraph.generated.models.notebook import Notebook
from msgraph.generated.models.onenote_section import OnenoteSection



# OneDrive-specific response wrapper
class OneDriveResponse:
    """Standardized OneDrive API response wrapper."""
    success: bool
    data: Optional[Dict[str, Any]] = None
    error: Optional[str] = None
    message: Optional[str] = None

    def __init__(self, success: bool, data: Optional[Dict[str, Any]] = None, error: Optional[str] = None, message: Optional[str] = None) -> None:
        self.success = success
        self.data = data
        self.error = error
        self.message = message

    def to_dict(self) -> Dict[str, Any]:
        result: Dict[str, Any] = {"success": self.success}
        if self.data is not None:
            result["data"] = self.data
        if self.error is not None:
            result["error"] = self.error
        if self.message is not None:
            result["message"] = self.message
        return result

    def to_json(self) -> str:
        return json.dumps(self.to_dict())

# Set up logger
logger = logging.getLogger(__name__)

class OneDriveDataSource:
    """
    Basic Microsoft OneDrive API client with core endpoint coverage.

    Features:
    - Basic OneDrive API coverage with 332 methods organized by operation type
    - Support for Personal OneDrive, User OneDrive, Group OneDrive, and SharePoint Document Libraries
    - Basic file and folder operations (read, list, copy, move, delete)
    - Search, discovery, and delta synchronization capabilities
    - Thumbnail and preview generation
    - File versioning and restore operations
    - Basic OData query parameter support optimized for OneDrive
    - Microsoft Graph SDK integration with OneDrive-specific optimizations
    - Async snake_case method names for all operations
    - Standardized OneDriveResponse format for all responses
    - Simple error handling and OneDrive-specific response processing

    EXCLUDED OPERATIONS (modify EXCLUDED_KEYWORDS list to change):
    - Upload operations (content, createUploadSession)
    - Sharing operations (permissions, invite, createLink)
    - Workbook operations (Excel file editing)
    - Chat operations (Teams chats)
    - Onenote operations (Onenote operations)
    - Device App Management operations (Device App Management operations)
    - Device Management operations (Device Management operations)
    - Connections operations (Connections operations)
    - Identity Governance operations (Identity Governance operations)
    - Analytics operations (Analytics operations)
    - Mail Folders operations (Mail Folders operations)
    - Storage operations (Storage operations)
    - Admin operations (Admin operations)
    - Agreements operations (Agreements operations)
    - Security operations (Security operations)
    - Directory operations (Directory operations)
    - Solutions operations (Solutions operations)
    - Onenote operations (Onenote operations)

    Operation Types:
    - File operations: Basic CRUD for drive items
    - Folder operations: Directory listing and navigation
    - Metadata operations: Thumbnails, analytics, preview
    - Discovery operations: Search, delta sync, recent files
    - General operations: Drive info and basic operations
    - Workbook operations: Excel file editing
    - Chat operations: Teams chats
    - Onenote operations: Onenote operations
    - Device App Management operations: Device App Management operations
    - Device Management operations: Device Management operations
    - Connections operations: Connections operations
    - Identity Governance operations: Identity Governance operations
    - Analytics operations: Analytics operations
    - Mail Folders operations: Mail Folders operations
    - Storage operations: Storage operations
    - Admin operations: Admin operations
    - Agreements operations: Agreements operations
    - Security operations: Security operations
    - Directory operations: Directory operations
    - Solutions operations: Solutions operations
    - Onenote operations: Onenote operations
    """

    def __init__(self, client: MSGraphClient) -> None:
        """Initialize with Microsoft Graph SDK client optimized for OneDrive."""
        self.client = client.get_client().get_ms_graph_service_client()
        if not hasattr(self.client, "me"):
            raise ValueError("Client must be a Microsoft Graph SDK client")
        logger.info("OneDrive client initialized with 332 methods")

    def _handle_onedrive_response(self, response: object) -> OneDriveResponse:
        """Handle OneDrive API response with comprehensive error handling."""
        try:
            if response is None:
                return OneDriveResponse(success=False, error="Empty response from OneDrive API")

            success = True
            error_msg = None

            # Enhanced error response handling for OneDrive operations
            if hasattr(response, 'error'):
                success = False
                error_msg = str(response.error)
            elif isinstance(response, dict) and 'error' in response:
                success = False
                error_info = response['error']
                if isinstance(error_info, dict):
                    error_code = error_info.get('code', 'Unknown')
                    error_message = error_info.get('message', 'No message')
                    error_msg = f"{error_code}: {error_message}"
                else:
                    error_msg = str(error_info)
            elif hasattr(response, 'code') and hasattr(response, 'message'):
                success = False
                error_msg = f"{response.code}: {response.message}"

            return OneDriveResponse(
                success=success,
                data=response,
                error=error_msg,
            )
        except Exception as e:
            logger.error(f"Error handling OneDrive response: {e}")
            return OneDriveResponse(success=False, error=str(e))

    def get_data_source(self) -> 'OneDriveDataSource':
        """Get the underlying OneDrive client."""
        return self

    # ========== FILE OPERATIONS (203 methods) ==========

    async def drives_drive_list_drive(
        self,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get entities from drives.
        OneDrive operation: GET /drives
        Operation type: file
        Args:
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_delete_drive(
        self,
        drive_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete entity from drives.
        OneDrive operation: DELETE /drives/{drive-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_get_drive(
        self,
        drive_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get entity from drives by key.
        OneDrive operation: GET /drives/{drive-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                for k, v in headers.items():
                    config.headers.add(k, v)

            # Add consistency level for search operations in OneDrive
            if search:
                config.headers.add('ConsistencyLevel', 'eventual')

            response = await self.client.drives.by_drive_id(drive_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_update_drive(
        self,
        drive_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update entity in drives.
        OneDrive operation: PATCH /drives/{drive-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_bundles(
        self,
        drive_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get bundles from drives.
        OneDrive operation: GET /drives/{drive-id}/bundles
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).bundles.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_get_bundles(
        self,
        drive_id: str,
        driveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get bundles from drives.
        OneDrive operation: GET /drives/{drive-id}/bundles/{driveItem-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).bundles.by_bundle_id(driveItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items(
        self,
        drive_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """drive: sharedWithMe.
        OneDrive operation: GET /drives/{drive-id}/items
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_delete_items(
        self,
        drive_id: str,
        driveItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property items for drives.
        OneDrive operation: DELETE /drives/{drive-id}/items/{driveItem-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).delete(request_configuration=config)
            if response is None:
                return OneDriveResponse(success=True, message="Item deleted successfully")
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_get_items(
        self,
        drive_id: str,
        driveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from drives.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            query_params = DriveItemItemRequestBuilder.DriveItemItemRequestBuilderGetQueryParameters()
            config = DriveItemItemRequestBuilder.DriveItemItemRequestBuilderGetRequestConfiguration()
            # Create proper typed request configuration
            # config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_update_items(
        self,
        drive_id: str,
        driveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        try:

            # Convert dict → Kiota DriveItem
            if isinstance(request_body, dict):
                item = DriveItemModel()
                if "name" in request_body:
                    item.name = request_body["name"]
                if "parentReference" in request_body:
                    ref = ItemReference()
                    pr = request_body["parentReference"]
                    ref.id = pr.get("id")
                    ref.drive_id = pr.get("driveId")
                    ref.path = pr.get("path")
                    item.parent_reference = ref
                item.additional_data = {
                    k: v for k, v in request_body.items()
                    if k.startswith("@")
                }
                body = item
            else:
                body = request_body

            query_params = DriveItemItemRequestBuilder.DriveItemItemRequestBuilderGetQueryParameters()
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]

            config = DriveItemItemRequestBuilder.DriveItemItemRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params
            config.headers.add("Content-Type", "application/json")
            if headers:
                for k, v in headers.items():
                    config.headers.add(k, v)

            response = await self.client.drives.by_drive_id(drive_id)\
                .items.by_drive_item_id(driveItem_id)\
                .patch(body=body, request_configuration=config)

            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_items_drive_item_assign_sensitivity_label(
        self,
        drive_id: str,
        driveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action assignSensitivityLabel.
        OneDrive operation: POST /drives/{drive-id}/items/{driveItem-id}/assignSensitivityLabel
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).assign_sensitivity_label.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_items_drive_item_checkin(
        self,
        drive_id: str,
        driveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action checkin.
        OneDrive operation: POST /drives/{drive-id}/items/{driveItem-id}/checkin
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).checkin.post(body=request_body, request_configuration=config)
            if response is None:
                return OneDriveResponse(success=True, message="Item checked in successfully")
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_items_drive_item_checkout(
        self,
        drive_id: str,
        driveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action checkout.
        OneDrive operation: POST /drives/{drive-id}/items/{driveItem-id}/checkout
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).checkout.post(request_configuration=config)
            if response is None:
                return OneDriveResponse(success=True, message="Item checked out successfully")
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_list_children(
        self,
        drive_id: str,
        driveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """List children of a driveItem.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/children
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).children.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_get_children(
        self,
        drive_id: str,
        driveItem_id: str,
        driveItem_id1: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get children from drives.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/children/{driveItem-id1}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            driveItem_id1 (str, required): OneDrive driveItem id1 identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).children.by_children_id(driveItem_id1).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_items_drive_item_copy(
        self,
        drive_id: str,
        driveItem_id: str,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        try:
            # Always reconstruct a proper Kiota object — never pass dict to .post()
            body = CopyPostRequestBody()

            if request_body is not None:
                # Handle both dict and already-built CopyPostRequestBody
                if isinstance(request_body, CopyPostRequestBody):
                    body = request_body
                else:
                    # Convert from dict
                    parent_data = request_body.get("parentReference") or {}
                    if parent_data:
                        ref = ItemReference()
                        ref.drive_id = parent_data.get("driveId")
                        ref.id = parent_data.get("id")
                        body.parent_reference = ref
                    if request_body.get("name"):
                        body.name = request_body["name"]

            response = await self.client.drives.by_drive_id(drive_id)\
                .items.by_drive_item_id(driveItem_id)\
                .copy.post(body=body)

            if response is None:
                return OneDriveResponse(success=True, message="Item copied successfully")
            return self._handle_onedrive_response(response)
        except Exception as e:
            logger.error("OneDrive API call failed: %s", e)
            return OneDriveResponse(success=False, error=f"OneDrive API call failed: {str(e)}")

    async def drives_drive_items_drive_item_extract_sensitivity_labels(
        self,
        drive_id: str,
        driveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action extractSensitivityLabels.
        OneDrive operation: POST /drives/{drive-id}/items/{driveItem-id}/extractSensitivityLabels
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).extract_sensitivity_labels.post(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_items_drive_item_follow(
        self,
        drive_id: str,
        driveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action follow.
        OneDrive operation: POST /drives/{drive-id}/items/{driveItem-id}/follow
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).follow.post(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_items_drive_item_get_activities_by_interval_ad27(
        self,
        drive_id: str,
        driveItem_id: str,
        startDateTime: str,
        endDateTime: str,
        interval: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function getActivitiesByInterval.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/getActivitiesByInterval(startDateTime='{startDateTime}',endDateTime='{endDateTime}',interval='{interval}')
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            startDateTime (str, required): OneDrive path parameter: startDateTime
            endDateTime (str, required): OneDrive path parameter: endDateTime
            interval (str, required): OneDrive path parameter: interval
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).get_activities_by_interval(start_date_time='{start_date_time}',end_date_time='{end_date_time}',interval='{interval}').get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_get_last_modified_by_user(
        self,
        drive_id: str,
        driveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get lastModifiedByUser from drives.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/lastModifiedByUser
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).last_modified_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_last_modified_by_user_list_service_provisioning_errors(
        self,
        drive_id: str,
        driveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/lastModifiedByUser/serviceProvisioningErrors
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).last_modified_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_get_list_item(
        self,
        drive_id: str,
        driveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get listItem from drives.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/listItem
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).list_item.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_items_drive_item_permanent_delete(
        self,
        drive_id: str,
        driveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action permanentDelete.
        OneDrive operation: POST /drives/{drive-id}/items/{driveItem-id}/permanentDelete
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).permanent_delete.post(request_configuration=config)
            if response is None:
                return OneDriveResponse(success=True, message="Item permanently deleted successfully")
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_items_drive_item_restore(
        self,
        drive_id: str,
        driveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action restore.
        OneDrive operation: POST /drives/{drive-id}/items/{driveItem-id}/restore
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).restore.post(body=request_body, request_configuration=config)
            if response is None:
                return OneDriveResponse(success=True, message="Version restored successfully")
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_list_subscriptions(
        self,
        drive_id: str,
        driveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get subscriptions from drives.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/subscriptions
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).subscriptions.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_delete_subscriptions(
        self,
        drive_id: str,
        driveItem_id: str,
        subscription_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property subscriptions for drives.
        OneDrive operation: DELETE /drives/{drive-id}/items/{driveItem-id}/subscriptions/{subscription-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            subscription_id (str, required): OneDrive subscription id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).subscriptions.by_subscription_id(subscription_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_get_subscriptions(
        self,
        drive_id: str,
        driveItem_id: str,
        subscription_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get subscriptions from drives.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/subscriptions/{subscription-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            subscription_id (str, required): OneDrive subscription id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).subscriptions.by_subscription_id(subscription_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_update_subscriptions(
        self,
        drive_id: str,
        driveItem_id: str,
        subscription_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property subscriptions in drives.
        OneDrive operation: PATCH /drives/{drive-id}/items/{driveItem-id}/subscriptions/{subscription-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            subscription_id (str, required): OneDrive subscription id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).subscriptions.by_subscription_id(subscription_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_items_drive_item_subscriptions_subscription_reauthorize(
        self,
        drive_id: str,
        driveItem_id: str,
        subscription_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action reauthorize.
        OneDrive operation: POST /drives/{drive-id}/items/{driveItem-id}/subscriptions/{subscription-id}/reauthorize
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            subscription_id (str, required): OneDrive subscription id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).subscriptions.by_subscription_id(subscription_id).reauthorize.post(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_items_drive_item_unfollow(
        self,
        drive_id: str,
        driveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action unfollow.
        OneDrive operation: POST /drives/{drive-id}/items/{driveItem-id}/unfollow
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).unfollow.post(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_list_versions(
        self,
        drive_id: str,
        driveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get versions from drives.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/versions
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).versions.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_delete_versions(
        self,
        drive_id: str,
        driveItem_id: str,
        driveItemVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property versions for drives.
        OneDrive operation: DELETE /drives/{drive-id}/items/{driveItem-id}/versions/{driveItemVersion-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            driveItemVersion_id (str, required): OneDrive driveItemVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).versions.by_version_id(driveItemVersion_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_get_versions(
        self,
        drive_id: str,
        driveItem_id: str,
        driveItemVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get versions from drives.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/versions/{driveItemVersion-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            driveItemVersion_id (str, required): OneDrive driveItemVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).versions.by_version_id(driveItemVersion_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_update_versions(
        self,
        drive_id: str,
        driveItem_id: str,
        driveItemVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property versions in drives.
        OneDrive operation: PATCH /drives/{drive-id}/items/{driveItem-id}/versions/{driveItemVersion-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            driveItemVersion_id (str, required): OneDrive driveItemVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).versions.by_version_id(driveItemVersion_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_get_last_modified_by_user(
        self,
        drive_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get lastModifiedByUser from drives.
        OneDrive operation: GET /drives/{drive-id}/lastModifiedByUser
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).last_modified_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_last_modified_by_user_list_service_provisioning_errors(
        self,
        drive_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /drives/{drive-id}/lastModifiedByUser/serviceProvisioningErrors
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).last_modified_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_delete_list(
        self,
        drive_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property list for drives.
        OneDrive operation: DELETE /drives/{drive-id}/list
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_get_list(
        self,
        drive_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get list from drives.
        OneDrive operation: GET /drives/{drive-id}/list
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_update_list(
        self,
        drive_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property list in drives.
        OneDrive operation: PATCH /drives/{drive-id}/list
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_list_columns(
        self,
        drive_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get columns from drives.
        OneDrive operation: GET /drives/{drive-id}/list/columns
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.columns.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_delete_columns(
        self,
        drive_id: str,
        columnDefinition_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property columns for drives.
        OneDrive operation: DELETE /drives/{drive-id}/list/columns/{columnDefinition-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            columnDefinition_id (str, required): OneDrive columnDefinition id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.columns.by_column_id(columnDefinition_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_get_columns(
        self,
        drive_id: str,
        columnDefinition_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get columns from drives.
        OneDrive operation: GET /drives/{drive-id}/list/columns/{columnDefinition-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            columnDefinition_id (str, required): OneDrive columnDefinition id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.columns.by_column_id(columnDefinition_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_update_columns(
        self,
        drive_id: str,
        columnDefinition_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property columns in drives.
        OneDrive operation: PATCH /drives/{drive-id}/list/columns/{columnDefinition-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            columnDefinition_id (str, required): OneDrive columnDefinition id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.columns.by_column_id(columnDefinition_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_get_drive(
        self,
        drive_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drive from drives.
        OneDrive operation: GET /drives/{drive-id}/list/drive
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.drive.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_list_items(
        self,
        drive_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from drives.
        OneDrive operation: GET /drives/{drive-id}/list/items
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_delete_items(
        self,
        drive_id: str,
        listItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property items for drives.
        OneDrive operation: DELETE /drives/{drive-id}/list/items/{listItem-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_get_items(
        self,
        drive_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from drives.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_update_items(
        self,
        drive_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property items in drives.
        OneDrive operation: PATCH /drives/{drive-id}/list/items/{listItem-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_list_document_set_versions(
        self,
        drive_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get documentSetVersions from drives.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}/documentSetVersions
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).document_set_versions.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_delete_document_set_versions(
        self,
        drive_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property documentSetVersions for drives.
        OneDrive operation: DELETE /drives/{drive-id}/list/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_get_document_set_versions(
        self,
        drive_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get documentSetVersions from drives.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_update_document_set_versions(
        self,
        drive_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property documentSetVersions in drives.
        OneDrive operation: PATCH /drives/{drive-id}/list/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_document_set_versions_delete_fields(
        self,
        drive_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property fields for drives.
        OneDrive operation: DELETE /drives/{drive-id}/list/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/fields
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).fields.delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_document_set_versions_get_fields(
        self,
        drive_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get fields from drives.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/fields
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).fields.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_document_set_versions_update_fields(
        self,
        drive_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property fields in drives.
        OneDrive operation: PATCH /drives/{drive-id}/list/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/fields
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).fields.patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_list_items_list_item_document_set_versions_document_set_version_restore(
        self,
        drive_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action restore.
        OneDrive operation: POST /drives/{drive-id}/list/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/restore
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).restore.post(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_get_drive_item(
        self,
        drive_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get driveItem from drives.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}/driveItem
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).drive_item.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_delete_fields(
        self,
        drive_id: str,
        listItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property fields for drives.
        OneDrive operation: DELETE /drives/{drive-id}/list/items/{listItem-id}/fields
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).fields.delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_get_fields(
        self,
        drive_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get fields from drives.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}/fields
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).fields.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_update_fields(
        self,
        drive_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property fields in drives.
        OneDrive operation: PATCH /drives/{drive-id}/list/items/{listItem-id}/fields
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).fields.patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_list_items_list_item_get_activities_by_interval_4c35(
        self,
        drive_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function getActivitiesByInterval.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}/getActivitiesByInterval()
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).get_activities_by_interval().get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_list_items_list_item_get_activities_by_interval_ad27(
        self,
        drive_id: str,
        listItem_id: str,
        startDateTime: str,
        endDateTime: str,
        interval: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function getActivitiesByInterval.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}/getActivitiesByInterval(startDateTime='{startDateTime}',endDateTime='{endDateTime}',interval='{interval}')
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            startDateTime (str, required): OneDrive path parameter: startDateTime
            endDateTime (str, required): OneDrive path parameter: endDateTime
            interval (str, required): OneDrive path parameter: interval
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).get_activities_by_interval(start_date_time='{start_date_time}',end_date_time='{end_date_time}',interval='{interval}').get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_get_last_modified_by_user(
        self,
        drive_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get lastModifiedByUser from drives.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}/lastModifiedByUser
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).last_modified_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_last_modified_by_user_list_service_provisioning_errors(
        self,
        drive_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}/lastModifiedByUser/serviceProvisioningErrors
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).last_modified_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_list_versions(
        self,
        drive_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get versions from drives.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}/versions
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).versions.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_delete_versions(
        self,
        drive_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property versions for drives.
        OneDrive operation: DELETE /drives/{drive-id}/list/items/{listItem-id}/versions/{listItemVersion-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_get_versions(
        self,
        drive_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get versions from drives.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}/versions/{listItemVersion-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_update_versions(
        self,
        drive_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property versions in drives.
        OneDrive operation: PATCH /drives/{drive-id}/list/items/{listItem-id}/versions/{listItemVersion-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_versions_delete_fields(
        self,
        drive_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property fields for drives.
        OneDrive operation: DELETE /drives/{drive-id}/list/items/{listItem-id}/versions/{listItemVersion-id}/fields
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).fields.delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_versions_get_fields(
        self,
        drive_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get fields from drives.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}/versions/{listItemVersion-id}/fields
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).fields.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_versions_update_fields(
        self,
        drive_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property fields in drives.
        OneDrive operation: PATCH /drives/{drive-id}/list/items/{listItem-id}/versions/{listItemVersion-id}/fields
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).fields.patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_get_last_modified_by_user(
        self,
        drive_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get lastModifiedByUser from drives.
        OneDrive operation: GET /drives/{drive-id}/list/lastModifiedByUser
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.last_modified_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_last_modified_by_user_list_service_provisioning_errors(
        self,
        drive_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /drives/{drive-id}/list/lastModifiedByUser/serviceProvisioningErrors
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.last_modified_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_list_operations(
        self,
        drive_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get operations from drives.
        OneDrive operation: GET /drives/{drive-id}/list/operations
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.operations.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_delete_operations(
        self,
        drive_id: str,
        richLongRunningOperation_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property operations for drives.
        OneDrive operation: DELETE /drives/{drive-id}/list/operations/{richLongRunningOperation-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            richLongRunningOperation_id (str, required): OneDrive richLongRunningOperation id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.operations.by_operation_id(richLongRunningOperation_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_get_operations(
        self,
        drive_id: str,
        richLongRunningOperation_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get operations from drives.
        OneDrive operation: GET /drives/{drive-id}/list/operations/{richLongRunningOperation-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            richLongRunningOperation_id (str, required): OneDrive richLongRunningOperation id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.operations.by_operation_id(richLongRunningOperation_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_update_operations(
        self,
        drive_id: str,
        richLongRunningOperation_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property operations in drives.
        OneDrive operation: PATCH /drives/{drive-id}/list/operations/{richLongRunningOperation-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            richLongRunningOperation_id (str, required): OneDrive richLongRunningOperation id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.operations.by_operation_id(richLongRunningOperation_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_list_subscriptions(
        self,
        drive_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get subscriptions from drives.
        OneDrive operation: GET /drives/{drive-id}/list/subscriptions
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.subscriptions.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_delete_subscriptions(
        self,
        drive_id: str,
        subscription_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property subscriptions for drives.
        OneDrive operation: DELETE /drives/{drive-id}/list/subscriptions/{subscription-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            subscription_id (str, required): OneDrive subscription id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.subscriptions.by_subscription_id(subscription_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_get_subscriptions(
        self,
        drive_id: str,
        subscription_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get subscriptions from drives.
        OneDrive operation: GET /drives/{drive-id}/list/subscriptions/{subscription-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            subscription_id (str, required): OneDrive subscription id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.subscriptions.by_subscription_id(subscription_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_update_subscriptions(
        self,
        drive_id: str,
        subscription_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property subscriptions in drives.
        OneDrive operation: PATCH /drives/{drive-id}/list/subscriptions/{subscription-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            subscription_id (str, required): OneDrive subscription id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.subscriptions.by_subscription_id(subscription_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_list_subscriptions_subscription_reauthorize(
        self,
        drive_id: str,
        subscription_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action reauthorize.
        OneDrive operation: POST /drives/{drive-id}/list/subscriptions/{subscription-id}/reauthorize
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            subscription_id (str, required): OneDrive subscription id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.subscriptions.by_subscription_id(subscription_id).reauthorize.post(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_get_root(
        self,
        drive_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get root from drives.
        OneDrive operation: GET /drives/{drive-id}/root
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).root.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_special(
        self,
        drive_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get special from drives.
        OneDrive operation: GET /drives/{drive-id}/special
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).special.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_get_special(
        self,
        drive_id: str,
        driveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get special from drives.
        OneDrive operation: GET /drives/{drive-id}/special/{driveItem-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).special.by_special_id(driveItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_get_drive(
        self,
        group_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drive from groups.
        OneDrive operation: GET /groups/{group-id}/drive
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DriveRequestBuilder.DriveRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DriveRequestBuilder.DriveRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).drive.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_list_drives(
        self,
        group_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drives from groups.
        OneDrive operation: GET /groups/{group-id}/drives
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).drives.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_get_drives(
        self,
        group_id: str,
        drive_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drives from groups.
        OneDrive operation: GET /groups/{group-id}/drives/{drive-id}
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            drive_id (str, required): OneDrive drive id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).drives.by_drive_id(drive_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_get_photos(
        self,
        group_id: str,
        profilePhoto_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get photos from groups.
        OneDrive operation: GET /groups/{group-id}/photos/{profilePhoto-id}
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            profilePhoto_id (str, required): OneDrive profilePhoto id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).photos.by_photo_id(profilePhoto_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_get_drive(
        self,
        group_id: str,
        site_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drive from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/drive
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DriveRequestBuilder.DriveRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DriveRequestBuilder.DriveRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).drive.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_list_drives(
        self,
        group_id: str,
        site_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drives from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/drives
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).drives.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_get_drives(
        self,
        group_id: str,
        site_id: str,
        drive_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drives from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/drives/{drive-id}
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            drive_id (str, required): OneDrive drive id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).drives.by_drive_id(drive_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_get_by_path_get_drive(
        self,
        group_id: str,
        site_id: str,
        path: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drive from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/getByPath(path='{path}')/drive
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            path (str, required): OneDrive item path: path
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).get_by_path(path='{path}').drive.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_get_by_path_list_drives(
        self,
        group_id: str,
        site_id: str,
        path: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drives from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/getByPath(path='{path}')/drives
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            path (str, required): OneDrive item path: path
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).get_by_path(path='{path}').drives.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_get_by_path_list_items(
        self,
        group_id: str,
        site_id: str,
        path: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/getByPath(path='{path}')/items
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            path (str, required): OneDrive item path: path
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).get_by_path(path='{path}').items.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_list_items(
        self,
        group_id: str,
        site_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/items
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).items.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_get_items(
        self,
        group_id: str,
        site_id: str,
        baseItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/items/{baseItem-id}
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            baseItem_id (str, required): OneDrive baseItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).items.by_drive_item_id(baseItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_get_drive(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drive from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/drive
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).drive.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_list_items(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_delete_items(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property items for groups.
        OneDrive operation: DELETE /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_get_items(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_update_items(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property items in groups.
        OneDrive operation: PATCH /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_list_document_set_versions(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get documentSetVersions from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_delete_document_set_versions(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property documentSetVersions for groups.
        OneDrive operation: DELETE /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_get_document_set_versions(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get documentSetVersions from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_update_document_set_versions(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property documentSetVersions in groups.
        OneDrive operation: PATCH /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_document_set_versions_delete_fields(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property fields for groups.
        OneDrive operation: DELETE /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/fields
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).fields.delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_document_set_versions_get_fields(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get fields from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/fields
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).fields.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_document_set_versions_update_fields(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property fields in groups.
        OneDrive operation: PATCH /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/fields
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).fields.patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_group_sites_site_lists_list_items_list_item_document_set_versions_document_set_version_restore(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action restore.
        OneDrive operation: POST /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/restore
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).restore.post(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_get_drive_item(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get driveItem from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/driveItem
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).drive_item.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_delete_fields(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property fields for groups.
        OneDrive operation: DELETE /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/fields
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).fields.delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_get_fields(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get fields from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/fields
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).fields.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_update_fields(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property fields in groups.
        OneDrive operation: PATCH /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/fields
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).fields.patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_group_sites_site_lists_list_items_list_item_get_activities_by_interval_4c35(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function getActivitiesByInterval.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/getActivitiesByInterval()
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).get_activities_by_interval().get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_group_sites_site_lists_list_items_list_item_get_activities_by_interval_ad27(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        startDateTime: str,
        endDateTime: str,
        interval: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function getActivitiesByInterval.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/getActivitiesByInterval(startDateTime='{startDateTime}',endDateTime='{endDateTime}',interval='{interval}')
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            startDateTime (str, required): OneDrive path parameter: startDateTime
            endDateTime (str, required): OneDrive path parameter: endDateTime
            interval (str, required): OneDrive path parameter: interval
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).get_activities_by_interval(start_date_time='{start_date_time}',end_date_time='{end_date_time}',interval='{interval}').get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_get_last_modified_by_user(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get lastModifiedByUser from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/lastModifiedByUser
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).last_modified_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_last_modified_by_user_list_service_provisioning_errors(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/lastModifiedByUser/serviceProvisioningErrors
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).last_modified_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_list_versions(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get versions from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_delete_versions(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property versions for groups.
        OneDrive operation: DELETE /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions/{listItemVersion-id}
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_get_versions(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get versions from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions/{listItemVersion-id}
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_update_versions(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property versions in groups.
        OneDrive operation: PATCH /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions/{listItemVersion-id}
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_versions_delete_fields(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property fields for groups.
        OneDrive operation: DELETE /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions/{listItemVersion-id}/fields
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).fields.delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_versions_get_fields(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get fields from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions/{listItemVersion-id}/fields
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).fields.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_versions_update_fields(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property fields in groups.
        OneDrive operation: PATCH /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions/{listItemVersion-id}/fields
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).fields.patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_team_channels_get_files_folder(
        self,
        group_id: str,
        channel_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get filesFolder from groups.
        OneDrive operation: GET /groups/{group-id}/team/channels/{channel-id}/filesFolder
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            channel_id (str, required): OneDrive channel id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).team.channels.by_channel_id(channel_id).files_folder.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_team_primary_channel_get_files_folder(
        self,
        group_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get filesFolder from groups.
        OneDrive operation: GET /groups/{group-id}/team/primaryChannel/filesFolder
        Operation type: file
        Args:
            group_id (str, required): OneDrive group id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).team.primary_channel.files_folder.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def identity_protection_risky_service_principals_delete_history(
        self,
        riskyServicePrincipal_id: str,
        riskyServicePrincipalHistoryItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property history for identityProtection.
        OneDrive operation: DELETE /identityProtection/riskyServicePrincipals/{riskyServicePrincipal-id}/history/{riskyServicePrincipalHistoryItem-id}
        Operation type: file
        Args:
            riskyServicePrincipal_id (str, required): OneDrive riskyServicePrincipal id identifier
            riskyServicePrincipalHistoryItem_id (str, required): OneDrive riskyServicePrincipalHistoryItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.identity_protection.risky_service_principals.by_riskyServicePrincipal_id(riskyServicePrincipal_id).history.by_history_id(riskyServicePrincipalHistoryItem_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def identity_protection_risky_service_principals_get_history(
        self,
        riskyServicePrincipal_id: str,
        riskyServicePrincipalHistoryItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get history from identityProtection.
        OneDrive operation: GET /identityProtection/riskyServicePrincipals/{riskyServicePrincipal-id}/history/{riskyServicePrincipalHistoryItem-id}
        Operation type: file
        Args:
            riskyServicePrincipal_id (str, required): OneDrive riskyServicePrincipal id identifier
            riskyServicePrincipalHistoryItem_id (str, required): OneDrive riskyServicePrincipalHistoryItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.identity_protection.risky_service_principals.by_riskyServicePrincipal_id(riskyServicePrincipal_id).history.by_history_id(riskyServicePrincipalHistoryItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def identity_protection_risky_service_principals_update_history(
        self,
        riskyServicePrincipal_id: str,
        riskyServicePrincipalHistoryItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property history in identityProtection.
        OneDrive operation: PATCH /identityProtection/riskyServicePrincipals/{riskyServicePrincipal-id}/history/{riskyServicePrincipalHistoryItem-id}
        Operation type: file
        Args:
            riskyServicePrincipal_id (str, required): OneDrive riskyServicePrincipal id identifier
            riskyServicePrincipalHistoryItem_id (str, required): OneDrive riskyServicePrincipalHistoryItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.identity_protection.risky_service_principals.by_riskyServicePrincipal_id(riskyServicePrincipal_id).history.by_history_id(riskyServicePrincipalHistoryItem_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def identity_protection_risky_users_delete_history(
        self,
        riskyUser_id: str,
        riskyUserHistoryItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property history for identityProtection.
        OneDrive operation: DELETE /identityProtection/riskyUsers/{riskyUser-id}/history/{riskyUserHistoryItem-id}
        Operation type: file
        Args:
            riskyUser_id (str, required): OneDrive riskyUser id identifier
            riskyUserHistoryItem_id (str, required): OneDrive riskyUserHistoryItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.identity_protection.risky_users.by_riskyUser_id(riskyUser_id).history.by_history_id(riskyUserHistoryItem_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def identity_protection_risky_users_get_history(
        self,
        riskyUser_id: str,
        riskyUserHistoryItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get history from identityProtection.
        OneDrive operation: GET /identityProtection/riskyUsers/{riskyUser-id}/history/{riskyUserHistoryItem-id}
        Operation type: file
        Args:
            riskyUser_id (str, required): OneDrive riskyUser id identifier
            riskyUserHistoryItem_id (str, required): OneDrive riskyUserHistoryItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.identity_protection.risky_users.by_riskyUser_id(riskyUser_id).history.by_history_id(riskyUserHistoryItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def identity_protection_risky_users_update_history(
        self,
        riskyUser_id: str,
        riskyUserHistoryItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property history in identityProtection.
        OneDrive operation: PATCH /identityProtection/riskyUsers/{riskyUser-id}/history/{riskyUserHistoryItem-id}
        Operation type: file
        Args:
            riskyUser_id (str, required): OneDrive riskyUser id identifier
            riskyUserHistoryItem_id (str, required): OneDrive riskyUserHistoryItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.identity_protection.risky_users.by_riskyUser_id(riskyUser_id).history.by_history_id(riskyUserHistoryItem_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_activities_list_history_items(
        self,
        userActivity_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get historyItems from me.
        OneDrive operation: GET /me/activities/{userActivity-id}/historyItems
        Operation type: file
        Args:
            userActivity_id (str, required): OneDrive userActivity id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.activities.by_activitie_id(userActivity_id).history_items.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_activities_delete_history_items(
        self,
        userActivity_id: str,
        activityHistoryItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property historyItems for me.
        OneDrive operation: DELETE /me/activities/{userActivity-id}/historyItems/{activityHistoryItem-id}
        Operation type: file
        Args:
            userActivity_id (str, required): OneDrive userActivity id identifier
            activityHistoryItem_id (str, required): OneDrive activityHistoryItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.activities.by_activitie_id(userActivity_id).history_items.by_historyItem_id(activityHistoryItem_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_activities_get_history_items(
        self,
        userActivity_id: str,
        activityHistoryItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get historyItems from me.
        OneDrive operation: GET /me/activities/{userActivity-id}/historyItems/{activityHistoryItem-id}
        Operation type: file
        Args:
            userActivity_id (str, required): OneDrive userActivity id identifier
            activityHistoryItem_id (str, required): OneDrive activityHistoryItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.activities.by_activitie_id(userActivity_id).history_items.by_historyItem_id(activityHistoryItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_activities_update_history_items(
        self,
        userActivity_id: str,
        activityHistoryItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete an activityHistoryItem.
        OneDrive operation: PATCH /me/activities/{userActivity-id}/historyItems/{activityHistoryItem-id}
        Operation type: file
        Args:
            userActivity_id (str, required): OneDrive userActivity id identifier
            activityHistoryItem_id (str, required): OneDrive activityHistoryItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.activities.by_activitie_id(userActivity_id).history_items.by_historyItem_id(activityHistoryItem_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_activities_history_items_get_activity(
        self,
        userActivity_id: str,
        activityHistoryItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get activity from me.
        OneDrive operation: GET /me/activities/{userActivity-id}/historyItems/{activityHistoryItem-id}/activity
        Operation type: file
        Args:
            userActivity_id (str, required): OneDrive userActivity id identifier
            activityHistoryItem_id (str, required): OneDrive activityHistoryItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.activities.by_activitie_id(userActivity_id).history_items.by_historyItem_id(activityHistoryItem_id).activity.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_cloud_clipboard_list_items(
        self,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from me.
        OneDrive operation: GET /me/cloudClipboard/items
        Operation type: file
        Args:
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.cloud_clipboard.items.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_cloud_clipboard_delete_items(
        self,
        cloudClipboardItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property items for me.
        OneDrive operation: DELETE /me/cloudClipboard/items/{cloudClipboardItem-id}
        Operation type: file
        Args:
            cloudClipboardItem_id (str, required): OneDrive cloudClipboardItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.cloud_clipboard.items.by_drive_item_id(cloudClipboardItem_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_cloud_clipboard_get_items(
        self,
        cloudClipboardItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from me.
        OneDrive operation: GET /me/cloudClipboard/items/{cloudClipboardItem-id}
        Operation type: file
        Args:
            cloudClipboardItem_id (str, required): OneDrive cloudClipboardItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.cloud_clipboard.items.by_drive_item_id(cloudClipboardItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_cloud_clipboard_update_items(
        self,
        cloudClipboardItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property items in me.
        OneDrive operation: PATCH /me/cloudClipboard/items/{cloudClipboardItem-id}
        Operation type: file
        Args:
            cloudClipboardItem_id (str, required): OneDrive cloudClipboardItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.cloud_clipboard.items.by_drive_item_id(cloudClipboardItem_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_get_drive(
        self,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get Drive.
        OneDrive operation: GET /me/drive
        Operation type: file
        Args:
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DriveRequestBuilder.DriveRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DriveRequestBuilder.DriveRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.drive.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_list_drives(
        self,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """List available drives.
        OneDrive operation: GET /me/drives
        Operation type: file
        Args:
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DriveRequestBuilder.DriveRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DriveRequestBuilder.DriveRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                for k, v in headers.items():
                    config.headers.add(k, v)

            # Add consistency level for search operations in OneDrive
            if search:
                config.headers.add('ConsistencyLevel', 'eventual')

            response = await self.client.me.drives.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_get_drives(
        self,
        drive_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drives from me.
        OneDrive operation: GET /me/drives/{drive-id}
        Operation type: file
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DriveRequestBuilder.DriveRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DriveRequestBuilder.DriveRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.drives.by_drive_id(drive_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_joined_teams_channels_get_files_folder(
        self,
        team_id: str,
        channel_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get filesFolder from me.
        OneDrive operation: GET /me/joinedTeams/{team-id}/channels/{channel-id}/filesFolder
        Operation type: file
        Args:
            team_id (str, required): OneDrive team id identifier
            channel_id (str, required): OneDrive channel id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.joined_teams.by_joinedTeam_id(team_id).channels.by_channel_id(channel_id).files_folder.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_joined_teams_primary_channel_get_files_folder(
        self,
        team_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get filesFolder from me.
        OneDrive operation: GET /me/joinedTeams/{team-id}/primaryChannel/filesFolder
        Operation type: file
        Args:
            team_id (str, required): OneDrive team id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.joined_teams.by_joinedTeam_id(team_id).primary_channel.files_folder.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_get_photos(
        self,
        profilePhoto_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get photos from me.
        OneDrive operation: GET /me/photos/{profilePhoto-id}
        Operation type: file
        Args:
            profilePhoto_id (str, required): OneDrive profilePhoto id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.photos.by_photo_id(profilePhoto_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def reports_get_one_drive_activity_user_detail_77b1(
        self,
        date: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function getOneDriveActivityUserDetail.
        OneDrive operation: GET /reports/getOneDriveActivityUserDetail(date={date})
        Operation type: file
        Args:
            date (str, required): OneDrive path parameter: date
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.reports.get_one_drive_activity_user_detail(date={date}).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def reports_get_one_drive_activity_user_detail_657c(
        self,
        period: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function getOneDriveActivityUserDetail.
        OneDrive operation: GET /reports/getOneDriveActivityUserDetail(period='{period}')
        Operation type: file
        Args:
            period (str, required): OneDrive path parameter: period
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.reports.get_one_drive_activity_user_detail(period='{period}').get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_get_drive(
        self,
        site_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drive from sites.
        OneDrive operation: GET /sites/{site-id}/drive
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DriveRequestBuilder.DriveRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DriveRequestBuilder.DriveRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).drive.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_list_drives(
        self,
        site_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drives from sites.
        OneDrive operation: GET /sites/{site-id}/drives
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).drives.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_get_drives(
        self,
        site_id: str,
        drive_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drives from sites.
        OneDrive operation: GET /sites/{site-id}/drives/{drive-id}
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            drive_id (str, required): OneDrive drive id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).drives.by_drive_id(drive_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_get_by_path_get_drive(
        self,
        site_id: str,
        path: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drive from sites.
        OneDrive operation: GET /sites/{site-id}/getByPath(path='{path}')/drive
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            path (str, required): OneDrive item path: path
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).get_by_path(path='{path}').drive.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_get_by_path_list_drives(
        self,
        site_id: str,
        path: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drives from sites.
        OneDrive operation: GET /sites/{site-id}/getByPath(path='{path}')/drives
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            path (str, required): OneDrive item path: path
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).get_by_path(path='{path}').drives.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_get_by_path_list_items(
        self,
        site_id: str,
        path: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from sites.
        OneDrive operation: GET /sites/{site-id}/getByPath(path='{path}')/items
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            path (str, required): OneDrive item path: path
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).get_by_path(path='{path}').items.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_list_items(
        self,
        site_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from sites.
        OneDrive operation: GET /sites/{site-id}/items
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).items.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_get_items(
        self,
        site_id: str,
        baseItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from sites.
        OneDrive operation: GET /sites/{site-id}/items/{baseItem-id}
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            baseItem_id (str, required): OneDrive baseItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).items.by_drive_item_id(baseItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_get_drive(
        self,
        site_id: str,
        list_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drive from sites.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/drive
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).drive.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_list_items(
        self,
        site_id: str,
        list_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """List items.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_delete_items(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete an item from a list.
        OneDrive operation: DELETE /sites/{site-id}/lists/{list-id}/items/{listItem-id}
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_get_items(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get listItem.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/{listItem-id}
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_update_items(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property items in sites.
        OneDrive operation: PATCH /sites/{site-id}/lists/{list-id}/items/{listItem-id}
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_list_document_set_versions(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """List documentSetVersions.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_delete_document_set_versions(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete documentSetVersion.
        OneDrive operation: DELETE /sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_get_document_set_versions(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get documentSetVersion.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_update_document_set_versions(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property documentSetVersions in sites.
        OneDrive operation: PATCH /sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_document_set_versions_delete_fields(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property fields for sites.
        OneDrive operation: DELETE /sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/fields
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).fields.delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_document_set_versions_get_fields(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get fields from sites.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/fields
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).fields.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_document_set_versions_update_fields(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property fields in sites.
        OneDrive operation: PATCH /sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/fields
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).fields.patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_site_lists_list_items_list_item_document_set_versions_document_set_version_restore(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action restore.
        OneDrive operation: POST /sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/restore
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).restore.post(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_get_drive_item(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get driveItem from sites.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/{listItem-id}/driveItem
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).drive_item.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_delete_fields(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property fields for sites.
        OneDrive operation: DELETE /sites/{site-id}/lists/{list-id}/items/{listItem-id}/fields
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).fields.delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_get_fields(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get fields from sites.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/{listItem-id}/fields
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).fields.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_update_fields(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update listItem.
        OneDrive operation: PATCH /sites/{site-id}/lists/{list-id}/items/{listItem-id}/fields
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).fields.patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_site_lists_list_items_list_item_get_activities_by_interval_4c35(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function getActivitiesByInterval.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/{listItem-id}/getActivitiesByInterval()
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).get_activities_by_interval().get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_site_lists_list_items_list_item_get_activities_by_interval_ad27(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        startDateTime: str,
        endDateTime: str,
        interval: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function getActivitiesByInterval.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/{listItem-id}/getActivitiesByInterval(startDateTime='{startDateTime}',endDateTime='{endDateTime}',interval='{interval}')
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            startDateTime (str, required): OneDrive path parameter: startDateTime
            endDateTime (str, required): OneDrive path parameter: endDateTime
            interval (str, required): OneDrive path parameter: interval
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).get_activities_by_interval(start_date_time='{start_date_time}',end_date_time='{end_date_time}',interval='{interval}').get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_get_last_modified_by_user(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get lastModifiedByUser from sites.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/{listItem-id}/lastModifiedByUser
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).last_modified_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_last_modified_by_user_list_service_provisioning_errors(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/{listItem-id}/lastModifiedByUser/serviceProvisioningErrors
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).last_modified_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_delete_versions(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property versions for sites.
        OneDrive operation: DELETE /sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions/{listItemVersion-id}
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_get_versions(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get a ListItemVersion resource.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions/{listItemVersion-id}
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_update_versions(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property versions in sites.
        OneDrive operation: PATCH /sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions/{listItemVersion-id}
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_versions_delete_fields(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property fields for sites.
        OneDrive operation: DELETE /sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions/{listItemVersion-id}/fields
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).fields.delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_versions_get_fields(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get fields from sites.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions/{listItemVersion-id}/fields
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).fields.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_versions_update_fields(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property fields in sites.
        OneDrive operation: PATCH /sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions/{listItemVersion-id}/fields
        Operation type: file
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).fields.patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def teams_channels_get_files_folder(
        self,
        team_id: str,
        channel_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get filesFolder.
        OneDrive operation: GET /teams/{team-id}/channels/{channel-id}/filesFolder
        Operation type: file
        Args:
            team_id (str, required): OneDrive team id identifier
            channel_id (str, required): OneDrive channel id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.teams.by_team_id(team_id).channels.by_channel_id(channel_id).files_folder.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def teams_primary_channel_get_files_folder(
        self,
        team_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get filesFolder from teams.
        OneDrive operation: GET /teams/{team-id}/primaryChannel/filesFolder
        Operation type: file
        Args:
            team_id (str, required): OneDrive team id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.teams.by_team_id(team_id).primary_channel.files_folder.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def teamwork_deleted_teams_channels_get_files_folder(
        self,
        deletedTeam_id: str,
        channel_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get filesFolder from teamwork.
        OneDrive operation: GET /teamwork/deletedTeams/{deletedTeam-id}/channels/{channel-id}/filesFolder
        Operation type: file
        Args:
            deletedTeam_id (str, required): OneDrive deletedTeam id identifier
            channel_id (str, required): OneDrive channel id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.teamwork.deleted_teams.by_deletedTeam_id(deletedTeam_id).channels.by_channel_id(channel_id).files_folder.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_activities_list_history_items(
        self,
        user_id: str,
        userActivity_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get historyItems from users.
        OneDrive operation: GET /users/{user-id}/activities/{userActivity-id}/historyItems
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            userActivity_id (str, required): OneDrive userActivity id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).activities.by_activitie_id(userActivity_id).history_items.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_activities_delete_history_items(
        self,
        user_id: str,
        userActivity_id: str,
        activityHistoryItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property historyItems for users.
        OneDrive operation: DELETE /users/{user-id}/activities/{userActivity-id}/historyItems/{activityHistoryItem-id}
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            userActivity_id (str, required): OneDrive userActivity id identifier
            activityHistoryItem_id (str, required): OneDrive activityHistoryItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).activities.by_activitie_id(userActivity_id).history_items.by_historyItem_id(activityHistoryItem_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_activities_get_history_items(
        self,
        user_id: str,
        userActivity_id: str,
        activityHistoryItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get historyItems from users.
        OneDrive operation: GET /users/{user-id}/activities/{userActivity-id}/historyItems/{activityHistoryItem-id}
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            userActivity_id (str, required): OneDrive userActivity id identifier
            activityHistoryItem_id (str, required): OneDrive activityHistoryItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).activities.by_activitie_id(userActivity_id).history_items.by_historyItem_id(activityHistoryItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_activities_update_history_items(
        self,
        user_id: str,
        userActivity_id: str,
        activityHistoryItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property historyItems in users.
        OneDrive operation: PATCH /users/{user-id}/activities/{userActivity-id}/historyItems/{activityHistoryItem-id}
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            userActivity_id (str, required): OneDrive userActivity id identifier
            activityHistoryItem_id (str, required): OneDrive activityHistoryItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).activities.by_activitie_id(userActivity_id).history_items.by_historyItem_id(activityHistoryItem_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_activities_history_items_get_activity(
        self,
        user_id: str,
        userActivity_id: str,
        activityHistoryItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get activity from users.
        OneDrive operation: GET /users/{user-id}/activities/{userActivity-id}/historyItems/{activityHistoryItem-id}/activity
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            userActivity_id (str, required): OneDrive userActivity id identifier
            activityHistoryItem_id (str, required): OneDrive activityHistoryItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).activities.by_activitie_id(userActivity_id).history_items.by_historyItem_id(activityHistoryItem_id).activity.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_cloud_clipboard_list_items(
        self,
        user_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from users.
        OneDrive operation: GET /users/{user-id}/cloudClipboard/items
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).cloud_clipboard.items.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_cloud_clipboard_delete_items(
        self,
        user_id: str,
        cloudClipboardItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property items for users.
        OneDrive operation: DELETE /users/{user-id}/cloudClipboard/items/{cloudClipboardItem-id}
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            cloudClipboardItem_id (str, required): OneDrive cloudClipboardItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).cloud_clipboard.items.by_drive_item_id(cloudClipboardItem_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_cloud_clipboard_get_items(
        self,
        user_id: str,
        cloudClipboardItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from users.
        OneDrive operation: GET /users/{user-id}/cloudClipboard/items/{cloudClipboardItem-id}
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            cloudClipboardItem_id (str, required): OneDrive cloudClipboardItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).cloud_clipboard.items.by_drive_item_id(cloudClipboardItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_cloud_clipboard_update_items(
        self,
        user_id: str,
        cloudClipboardItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property items in users.
        OneDrive operation: PATCH /users/{user-id}/cloudClipboard/items/{cloudClipboardItem-id}
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            cloudClipboardItem_id (str, required): OneDrive cloudClipboardItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).cloud_clipboard.items.by_drive_item_id(cloudClipboardItem_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_get_drive(
        self,
        user_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drive from users.
        OneDrive operation: GET /users/{user-id}/drive
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DriveRequestBuilder.DriveRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DriveRequestBuilder.DriveRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).drive.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_list_drives(
        self,
        user_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drives from users.
        OneDrive operation: GET /users/{user-id}/drives
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).drives.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_get_drives(
        self,
        user_id: str,
        drive_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drives from users.
        OneDrive operation: GET /users/{user-id}/drives/{drive-id}
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            drive_id (str, required): OneDrive drive id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).drives.by_drive_id(drive_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_joined_teams_channels_get_files_folder(
        self,
        user_id: str,
        team_id: str,
        channel_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get filesFolder from users.
        OneDrive operation: GET /users/{user-id}/joinedTeams/{team-id}/channels/{channel-id}/filesFolder
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            team_id (str, required): OneDrive team id identifier
            channel_id (str, required): OneDrive channel id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).joined_teams.by_joinedTeam_id(team_id).channels.by_channel_id(channel_id).files_folder.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_joined_teams_primary_channel_get_files_folder(
        self,
        user_id: str,
        team_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get filesFolder from users.
        OneDrive operation: GET /users/{user-id}/joinedTeams/{team-id}/primaryChannel/filesFolder
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            team_id (str, required): OneDrive team id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).joined_teams.by_joinedTeam_id(team_id).primary_channel.files_folder.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_get_photos(
        self,
        user_id: str,
        profilePhoto_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get photos from users.
        OneDrive operation: GET /users/{user-id}/photos/{profilePhoto-id}
        Operation type: file
        Args:
            user_id (str, required): OneDrive user id identifier
            profilePhoto_id (str, required): OneDrive profilePhoto id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).photos.by_photo_id(profilePhoto_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    # ========== FOLDER OPERATIONS (34 methods) ==========

    async def drives_drive_create_drive(
        self,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Add new entity to drives.
        OneDrive operation: POST /drives
        Operation type: folder
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_create_bundles(
        self,
        drive_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to bundles for drives.
        OneDrive operation: POST /drives/{drive-id}/bundles
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).bundles.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_get_created_by_user(
        self,
        drive_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get createdByUser from drives.
        OneDrive operation: GET /drives/{drive-id}/createdByUser
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).created_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_created_by_user_list_service_provisioning_errors(
        self,
        drive_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /drives/{drive-id}/createdByUser/serviceProvisioningErrors
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).created_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_create_items(
        self,
        drive_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to items for drives.
        OneDrive operation: POST /drives/{drive-id}/items
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_create_children(
        self,
        drive_id: str,
        driveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to children for drives.
        OneDrive operation: POST /drives/{drive-id}/items/{driveItem-id}/children
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).children.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_get_created_by_user(
        self,
        drive_id: str,
        driveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get createdByUser from drives.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/createdByUser
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).created_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_created_by_user_list_service_provisioning_errors(
        self,
        drive_id: str,
        driveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/createdByUser/serviceProvisioningErrors
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).created_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_create_subscriptions(
        self,
        drive_id: str,
        driveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to subscriptions for drives.
        OneDrive operation: POST /drives/{drive-id}/items/{driveItem-id}/subscriptions
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).subscriptions.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_create_versions(
        self,
        drive_id: str,
        driveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to versions for drives.
        OneDrive operation: POST /drives/{drive-id}/items/{driveItem-id}/versions
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).versions.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_create_columns(
        self,
        drive_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to columns for drives.
        OneDrive operation: POST /drives/{drive-id}/list/columns
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.columns.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_get_created_by_user(
        self,
        drive_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get createdByUser from drives.
        OneDrive operation: GET /drives/{drive-id}/list/createdByUser
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.created_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_created_by_user_list_service_provisioning_errors(
        self,
        drive_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /drives/{drive-id}/list/createdByUser/serviceProvisioningErrors
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.created_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_create_items(
        self,
        drive_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to items for drives.
        OneDrive operation: POST /drives/{drive-id}/list/items
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_get_created_by_user(
        self,
        drive_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get createdByUser from drives.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}/createdByUser
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).created_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_created_by_user_list_service_provisioning_errors(
        self,
        drive_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /drives/{drive-id}/list/items/{listItem-id}/createdByUser/serviceProvisioningErrors
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).created_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_create_document_set_versions(
        self,
        drive_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to documentSetVersions for drives.
        OneDrive operation: POST /drives/{drive-id}/list/items/{listItem-id}/documentSetVersions
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).document_set_versions.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_items_create_versions(
        self,
        drive_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to versions for drives.
        OneDrive operation: POST /drives/{drive-id}/list/items/{listItem-id}/versions
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).versions.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_create_operations(
        self,
        drive_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to operations for drives.
        OneDrive operation: POST /drives/{drive-id}/list/operations
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.operations.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_list_create_subscriptions(
        self,
        drive_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to subscriptions for drives.
        OneDrive operation: POST /drives/{drive-id}/list/subscriptions
        Operation type: folder
        Args:
            drive_id (str, required): OneDrive drive id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.subscriptions.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_create_items(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to items for groups.
        OneDrive operation: POST /groups/{group-id}/sites/{site-id}/lists/{list-id}/items
        Operation type: folder
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_get_created_by_user(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get createdByUser from groups.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/createdByUser
        Operation type: folder
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).created_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_created_by_user_list_service_provisioning_errors(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/createdByUser/serviceProvisioningErrors
        Operation type: folder
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).created_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_create_document_set_versions(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to documentSetVersions for groups.
        OneDrive operation: POST /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions
        Operation type: folder
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_sites_lists_items_create_versions(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to versions for groups.
        OneDrive operation: POST /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions
        Operation type: folder
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_activities_create_history_items(
        self,
        userActivity_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to historyItems for me.
        OneDrive operation: POST /me/activities/{userActivity-id}/historyItems
        Operation type: folder
        Args:
            userActivity_id (str, required): OneDrive userActivity id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.activities.by_activitie_id(userActivity_id).history_items.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_cloud_clipboard_create_items(
        self,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to items for me.
        OneDrive operation: POST /me/cloudClipboard/items
        Operation type: folder
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.cloud_clipboard.items.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_create_items(
        self,
        site_id: str,
        list_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create a new item in a list.
        OneDrive operation: POST /sites/{site-id}/lists/{list-id}/items
        Operation type: folder
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_get_created_by_user(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get createdByUser from sites.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/{listItem-id}/createdByUser
        Operation type: folder
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).created_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_created_by_user_list_service_provisioning_errors(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/{listItem-id}/createdByUser/serviceProvisioningErrors
        Operation type: folder
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).created_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_create_document_set_versions(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create documentSetVersion.
        OneDrive operation: POST /sites/{site-id}/lists/{list-id}/items/{listItem-id}/documentSetVersions
        Operation type: folder
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).document_set_versions.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_lists_items_create_versions(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to versions for sites.
        OneDrive operation: POST /sites/{site-id}/lists/{list-id}/items/{listItem-id}/versions
        Operation type: folder
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).versions.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_activities_create_history_items(
        self,
        user_id: str,
        userActivity_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to historyItems for users.
        OneDrive operation: POST /users/{user-id}/activities/{userActivity-id}/historyItems
        Operation type: folder
        Args:
            user_id (str, required): OneDrive user id identifier
            userActivity_id (str, required): OneDrive userActivity id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).activities.by_activitie_id(userActivity_id).history_items.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def users_cloud_clipboard_create_items(
        self,
        user_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to items for users.
        OneDrive operation: POST /users/{user-id}/cloudClipboard/items
        Operation type: folder
        Args:
            user_id (str, required): OneDrive user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).cloud_clipboard.items.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    # ========== SHARING OPERATIONS (76 methods) ==========

    async def drives_drive_list_items_list_item_create_link(
        self,
        drive_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action createLink.
        OneDrive operation: POST /drives/{drive-id}/list/items/{listItem-id}/createLink
        Operation type: sharing
        Args:
            drive_id (str, required): OneDrive drive id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.by_drive_item_id(listItem_id).create_link.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_insights_shared(
        self,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
    ) -> OneDriveResponse:
        """
        Fetch files shared with the current user via Office Graph Insights.
        Operation: GET /me/insights/shared
        """
        try:
            from msgraph.generated.users.item.insights.shared.shared_request_builder import SharedRequestBuilder

            query_params = SharedRequestBuilder.SharedRequestBuilderGetQueryParameters()

            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            config = RequestConfiguration(query_parameters=query_params)

            if headers:
                for k, v in headers.items():
                    config.headers.add(k, v)

            response = await self.client.me.insights.shared.get(request_configuration=config)
            return self._handle_onedrive_response(response)

        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive Insights API call failed: {str(e)}",
            )
    
    async def me_insights_shared_resource(
        self,
        insight_id: str,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """
        Fetch resource for a shared insight.
        Operation: GET /me/insights/shared/{insight-id}/resource
        """
        try:
            response = await self.client.me.insights.shared.by_shared_insight_id(insight_id).resource.get()
            return self._handle_onedrive_response(response)
        
        except Exception as e:
            return OneDriveResponse(
                success=False, 
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_group_sites_site_lists_list_items_list_item_create_link(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action createLink.
        OneDrive operation: POST /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/{listItem-id}/createLink
        Operation type: sharing
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).create_link.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_shared_drive_item_delete_shared_drive_item(
        self,
        sharedDriveItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete entity from shares.
        OneDrive operation: DELETE /shares/{sharedDriveItem-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_shared_drive_item_get_shared_drive_item(
        self,
        sharedDriveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Accessing shared DriveItems.
        OneDrive operation: GET /shares/{sharedDriveItem-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_shared_drive_item_update_shared_drive_item(
        self,
        sharedDriveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update entity in shares.
        OneDrive operation: PATCH /shares/{sharedDriveItem-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_get_created_by_user(
        self,
        sharedDriveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get createdByUser from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/createdByUser
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).created_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_created_by_user_list_service_provisioning_errors(
        self,
        sharedDriveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/createdByUser/serviceProvisioningErrors
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).created_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_get_drive_item(
        self,
        sharedDriveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Accessing shared DriveItems.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/driveItem
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).drive_item.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items(
        self,
        sharedDriveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/items
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).items.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_get_items(
        self,
        sharedDriveItem_id: str,
        driveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/items/{driveItem-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).items.by_drive_item_id(driveItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_get_last_modified_by_user(
        self,
        sharedDriveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get lastModifiedByUser from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/lastModifiedByUser
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).last_modified_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_last_modified_by_user_list_service_provisioning_errors(
        self,
        sharedDriveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/lastModifiedByUser/serviceProvisioningErrors
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).last_modified_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_delete_list(
        self,
        sharedDriveItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property list for shares.
        OneDrive operation: DELETE /shares/{sharedDriveItem-id}/list
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_get_list(
        self,
        sharedDriveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get list from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_update_list(
        self,
        sharedDriveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property list in shares.
        OneDrive operation: PATCH /shares/{sharedDriveItem-id}/list
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_create_columns(
        self,
        sharedDriveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to columns for shares.
        OneDrive operation: POST /shares/{sharedDriveItem-id}/list/columns
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.columns.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_list_columns(
        self,
        sharedDriveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get columns from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/columns
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.columns.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_delete_columns(
        self,
        sharedDriveItem_id: str,
        columnDefinition_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property columns for shares.
        OneDrive operation: DELETE /shares/{sharedDriveItem-id}/list/columns/{columnDefinition-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            columnDefinition_id (str, required): OneDrive columnDefinition id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.columns.by_column_id(columnDefinition_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_get_columns(
        self,
        sharedDriveItem_id: str,
        columnDefinition_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get columns from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/columns/{columnDefinition-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            columnDefinition_id (str, required): OneDrive columnDefinition id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.columns.by_column_id(columnDefinition_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_update_columns(
        self,
        sharedDriveItem_id: str,
        columnDefinition_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property columns in shares.
        OneDrive operation: PATCH /shares/{sharedDriveItem-id}/list/columns/{columnDefinition-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            columnDefinition_id (str, required): OneDrive columnDefinition id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.columns.by_column_id(columnDefinition_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_get_created_by_user(
        self,
        sharedDriveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get createdByUser from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/createdByUser
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.created_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_created_by_user_list_service_provisioning_errors(
        self,
        sharedDriveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/createdByUser/serviceProvisioningErrors
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.created_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_get_drive(
        self,
        sharedDriveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get drive from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/drive
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.drive.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_create_items(
        self,
        sharedDriveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to items for shares.
        OneDrive operation: POST /shares/{sharedDriveItem-id}/list/items
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_list_items(
        self,
        sharedDriveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_shared_drive_item_list_items_delta_fa14(
        self,
        sharedDriveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function delta.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/delta()
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.delta().get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_shared_drive_item_list_items_delta_9846(
        self,
        sharedDriveItem_id: str,
        token: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function delta.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/delta(token='{token}')
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            token (str, required): OneDrive path parameter: token
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.delta(token='{token}').get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_delete_items(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property items for shares.
        OneDrive operation: DELETE /shares/{sharedDriveItem-id}/list/items/{listItem-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_get_items(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get items from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_update_items(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property items in shares.
        OneDrive operation: PATCH /shares/{sharedDriveItem-id}/list/items/{listItem-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_shared_drive_item_list_items_list_item_create_link(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action createLink.
        OneDrive operation: POST /shares/{sharedDriveItem-id}/list/items/{listItem-id}/createLink
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).create_link.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_get_created_by_user(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get createdByUser from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}/createdByUser
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).created_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_created_by_user_list_service_provisioning_errors(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}/createdByUser/serviceProvisioningErrors
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).created_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_create_document_set_versions(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to documentSetVersions for shares.
        OneDrive operation: POST /shares/{sharedDriveItem-id}/list/items/{listItem-id}/documentSetVersions
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).document_set_versions.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_list_document_set_versions(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get documentSetVersions from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}/documentSetVersions
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).document_set_versions.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_delete_document_set_versions(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property documentSetVersions for shares.
        OneDrive operation: DELETE /shares/{sharedDriveItem-id}/list/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_get_document_set_versions(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get documentSetVersions from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_update_document_set_versions(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property documentSetVersions in shares.
        OneDrive operation: PATCH /shares/{sharedDriveItem-id}/list/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_document_set_versions_delete_fields(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property fields for shares.
        OneDrive operation: DELETE /shares/{sharedDriveItem-id}/list/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/fields
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).fields.delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_document_set_versions_get_fields(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get fields from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/fields
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).fields.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_document_set_versions_update_fields(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property fields in shares.
        OneDrive operation: PATCH /shares/{sharedDriveItem-id}/list/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/fields
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).fields.patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_shared_drive_item_list_items_list_item_document_set_versions_document_set_version_restore(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        documentSetVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action restore.
        OneDrive operation: POST /shares/{sharedDriveItem-id}/list/items/{listItem-id}/documentSetVersions/{documentSetVersion-id}/restore
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            documentSetVersion_id (str, required): OneDrive documentSetVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).document_set_versions.by_documentSetVersion_id(documentSetVersion_id).restore.post(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_get_drive_item(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get driveItem from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}/driveItem
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).drive_item.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_delete_fields(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property fields for shares.
        OneDrive operation: DELETE /shares/{sharedDriveItem-id}/list/items/{listItem-id}/fields
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).fields.delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_get_fields(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get fields from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}/fields
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).fields.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_update_fields(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property fields in shares.
        OneDrive operation: PATCH /shares/{sharedDriveItem-id}/list/items/{listItem-id}/fields
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).fields.patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_shared_drive_item_list_items_list_item_get_activities_by_interval_4c35(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function getActivitiesByInterval.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}/getActivitiesByInterval()
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).get_activities_by_interval().get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_shared_drive_item_list_items_list_item_get_activities_by_interval_ad27(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        startDateTime: str,
        endDateTime: str,
        interval: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function getActivitiesByInterval.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}/getActivitiesByInterval(startDateTime='{startDateTime}',endDateTime='{endDateTime}',interval='{interval}')
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            startDateTime (str, required): OneDrive path parameter: startDateTime
            endDateTime (str, required): OneDrive path parameter: endDateTime
            interval (str, required): OneDrive path parameter: interval
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).get_activities_by_interval(start_date_time='{start_date_time}',end_date_time='{end_date_time}',interval='{interval}').get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_get_last_modified_by_user(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get lastModifiedByUser from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}/lastModifiedByUser
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).last_modified_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_last_modified_by_user_list_service_provisioning_errors(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}/lastModifiedByUser/serviceProvisioningErrors
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).last_modified_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_create_versions(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to versions for shares.
        OneDrive operation: POST /shares/{sharedDriveItem-id}/list/items/{listItem-id}/versions
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).versions.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_list_versions(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get versions from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}/versions
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).versions.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_delete_versions(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property versions for shares.
        OneDrive operation: DELETE /shares/{sharedDriveItem-id}/list/items/{listItem-id}/versions/{listItemVersion-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_get_versions(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get versions from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}/versions/{listItemVersion-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_update_versions(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property versions in shares.
        OneDrive operation: PATCH /shares/{sharedDriveItem-id}/list/items/{listItem-id}/versions/{listItemVersion-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_versions_delete_fields(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property fields for shares.
        OneDrive operation: DELETE /shares/{sharedDriveItem-id}/list/items/{listItem-id}/versions/{listItemVersion-id}/fields
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).fields.delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_versions_get_fields(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get fields from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/items/{listItem-id}/versions/{listItemVersion-id}/fields
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).fields.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_items_versions_update_fields(
        self,
        sharedDriveItem_id: str,
        listItem_id: str,
        listItemVersion_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property fields in shares.
        OneDrive operation: PATCH /shares/{sharedDriveItem-id}/list/items/{listItem-id}/versions/{listItemVersion-id}/fields
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            listItemVersion_id (str, required): OneDrive listItemVersion id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.items.by_drive_item_id(listItem_id).versions.by_version_id(listItemVersion_id).fields.patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_get_last_modified_by_user(
        self,
        sharedDriveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get lastModifiedByUser from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/lastModifiedByUser
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.last_modified_by_user.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_last_modified_by_user_list_service_provisioning_errors(
        self,
        sharedDriveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get serviceProvisioningErrors property value.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/lastModifiedByUser/serviceProvisioningErrors
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.last_modified_by_user.service_provisioning_errors.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_create_operations(
        self,
        sharedDriveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to operations for shares.
        OneDrive operation: POST /shares/{sharedDriveItem-id}/list/operations
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.operations.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_list_operations(
        self,
        sharedDriveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get operations from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/operations
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.operations.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_delete_operations(
        self,
        sharedDriveItem_id: str,
        richLongRunningOperation_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property operations for shares.
        OneDrive operation: DELETE /shares/{sharedDriveItem-id}/list/operations/{richLongRunningOperation-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            richLongRunningOperation_id (str, required): OneDrive richLongRunningOperation id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.operations.by_operation_id(richLongRunningOperation_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_get_operations(
        self,
        sharedDriveItem_id: str,
        richLongRunningOperation_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get operations from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/operations/{richLongRunningOperation-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            richLongRunningOperation_id (str, required): OneDrive richLongRunningOperation id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.operations.by_operation_id(richLongRunningOperation_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_update_operations(
        self,
        sharedDriveItem_id: str,
        richLongRunningOperation_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property operations in shares.
        OneDrive operation: PATCH /shares/{sharedDriveItem-id}/list/operations/{richLongRunningOperation-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            richLongRunningOperation_id (str, required): OneDrive richLongRunningOperation id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.operations.by_operation_id(richLongRunningOperation_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_create_subscriptions(
        self,
        sharedDriveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to subscriptions for shares.
        OneDrive operation: POST /shares/{sharedDriveItem-id}/list/subscriptions
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.subscriptions.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_list_subscriptions(
        self,
        sharedDriveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get subscriptions from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/subscriptions
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.subscriptions.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_delete_subscriptions(
        self,
        sharedDriveItem_id: str,
        subscription_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property subscriptions for shares.
        OneDrive operation: DELETE /shares/{sharedDriveItem-id}/list/subscriptions/{subscription-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            subscription_id (str, required): OneDrive subscription id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.subscriptions.by_subscription_id(subscription_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_get_subscriptions(
        self,
        sharedDriveItem_id: str,
        subscription_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get subscriptions from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/list/subscriptions/{subscription-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            subscription_id (str, required): OneDrive subscription id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.subscriptions.by_subscription_id(subscription_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_list_update_subscriptions(
        self,
        sharedDriveItem_id: str,
        subscription_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property subscriptions in shares.
        OneDrive operation: PATCH /shares/{sharedDriveItem-id}/list/subscriptions/{subscription-id}
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            subscription_id (str, required): OneDrive subscription id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.subscriptions.by_subscription_id(subscription_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_shared_drive_item_list_subscriptions_subscription_reauthorize(
        self,
        sharedDriveItem_id: str,
        subscription_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action reauthorize.
        OneDrive operation: POST /shares/{sharedDriveItem-id}/list/subscriptions/{subscription-id}/reauthorize
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            subscription_id (str, required): OneDrive subscription id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list.subscriptions.by_subscription_id(subscription_id).reauthorize.post(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_get_list_item(
        self,
        sharedDriveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get listItem from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/listItem
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).list_item.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_get_root(
        self,
        sharedDriveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get root from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/root
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).root.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def shares_get_site(
        self,
        sharedDriveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get site from shares.
        OneDrive operation: GET /shares/{sharedDriveItem-id}/site
        Operation type: sharing
        Args:
            sharedDriveItem_id (str, required): OneDrive sharedDriveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.shares.by_share_id(sharedDriveItem_id).site.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_site_lists_list_items_list_item_create_link(
        self,
        site_id: str,
        list_id: str,
        listItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action createLink.
        OneDrive operation: POST /sites/{site-id}/lists/{list-id}/items/{listItem-id}/createLink
        Operation type: sharing
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            listItem_id (str, required): OneDrive listItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.by_drive_item_id(listItem_id).create_link.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    # ========== METADATA OPERATIONS (6 methods) ==========

    async def drives_drive_items_drive_item_preview(
        self,
        drive_id: str,
        driveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke action preview.
        OneDrive operation: POST /drives/{drive-id}/items/{driveItem-id}/preview
        Operation type: metadata
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).preview.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_create_thumbnails(
        self,
        drive_id: str,
        driveItem_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Create new navigation property to thumbnails for drives.
        OneDrive operation: POST /drives/{drive-id}/items/{driveItem-id}/thumbnails
        Operation type: metadata
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).thumbnails.post(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_list_thumbnails(
        self,
        drive_id: str,
        driveItem_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get thumbnails from drives.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/thumbnails
        Operation type: metadata
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).thumbnails.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_delete_thumbnails(
        self,
        drive_id: str,
        driveItem_id: str,
        thumbnailSet_id: str,
        If_Match: Optional[str] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Delete navigation property thumbnails for drives.
        OneDrive operation: DELETE /drives/{drive-id}/items/{driveItem-id}/thumbnails/{thumbnailSet-id}
        Operation type: metadata
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            thumbnailSet_id (str, required): OneDrive thumbnailSet id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).thumbnails.by_thumbnail_id(thumbnailSet_id).delete(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_get_thumbnails(
        self,
        drive_id: str,
        driveItem_id: str,
        thumbnailSet_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get thumbnails from drives.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/thumbnails/{thumbnailSet-id}
        Operation type: metadata
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            thumbnailSet_id (str, required): OneDrive thumbnailSet id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).thumbnails.by_thumbnail_id(thumbnailSet_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_update_thumbnails(
        self,
        drive_id: str,
        driveItem_id: str,
        thumbnailSet_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Update the navigation property thumbnails in drives.
        OneDrive operation: PATCH /drives/{drive-id}/items/{driveItem-id}/thumbnails/{thumbnailSet-id}
        Operation type: metadata
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            thumbnailSet_id (str, required): OneDrive thumbnailSet id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for file operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).thumbnails.by_thumbnail_id(thumbnailSet_id).patch(body=request_body, request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    # ========== DISCOVERY OPERATIONS (13 methods) ==========

    async def drives_list_following(
        self,
        drive_id: str,
        dollar_orderby: Optional[List[str]] = None,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get following from drives.
        OneDrive operation: GET /drives/{drive-id}/following
        Operation type: discovery
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_orderby (List[str], optional): Order items by property values
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).following.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_get_following(
        self,
        drive_id: str,
        driveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Get following from drives.
        OneDrive operation: GET /drives/{drive-id}/following/{driveItem-id}
        Operation type: discovery
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).following.by_following_id(driveItem_id).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_items_drive_item_delta_fa14(
        self,
        drive_id: str,
        driveItem_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function delta.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/delta()
        Operation type: discovery
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).delta().get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_items_drive_item_delta_9846(
        self,
        drive_id: str,
        driveItem_id: str,
        token: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function delta.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/delta(token='{token}')
        Operation type: discovery
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            token (str, required): OneDrive path parameter: token
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).delta(token='{token}').get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_items_drive_item_search(
        self,
        drive_id: str,
        driveItem_id: str,
        q: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function search.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/search(q='{q}')
        Operation type: discovery
        Args:
            drive_id (str, required): OneDrive drive id identifier
            driveItem_id (str, required): OneDrive driveItem id identifier
            q (str, required): OneDrive path parameter: q
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id(driveItem_id).search.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_list_items_delta_fa14(
        self,
        drive_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function delta.
        OneDrive operation: GET /drives/{drive-id}/list/items/delta()
        Operation type: discovery
        Args:
            drive_id (str, required): OneDrive drive id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.delta().get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_list_items_delta_9846(
        self,
        drive_id: str,
        token: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function delta.
        OneDrive operation: GET /drives/{drive-id}/list/items/delta(token='{token}')
        Operation type: discovery
        Args:
            drive_id (str, required): OneDrive drive id identifier
            token (str, required): OneDrive path parameter: token
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.drives.by_drive_id(drive_id).list.items.delta(token='{token}').get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_drive_recent(
        self,
        drive_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        try:
            query_params = RecentRequestBuilder.RecentRequestBuilderGetQueryParameters()

            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]

            config = RecentRequestBuilder.RecentRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            response = await self.client.drives.by_drive_id(drive_id).recent.get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(success=False, error=f"OneDrive API call failed: {str(e)}")

    async def drives_drive_search(
        self,
        drive_id: str,
        q: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function search.
        OneDrive operation: GET /drives/{drive-id}/search(q='{q}')
        Operation type: discovery
        Args:
            drive_id (str, required): OneDrive drive id identifier
            q (str, required): OneDrive path parameter: q
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = DrivesRequestBuilder.DrivesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = DrivesRequestBuilder.DrivesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                for k, v in headers.items():
                    config.headers.add(k, v)

            # Add consistency level for search operations in OneDrive
            if search:
                config.headers.add('ConsistencyLevel', 'eventual')

            response = await self.client.drives.by_drive_id(drive_id).items.by_drive_item_id('root').search_with_q(q).get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_group_sites_site_lists_list_items_delta_fa14(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function delta.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/delta()
        Operation type: discovery
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.delta().get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def groups_group_sites_site_lists_list_items_delta_9846(
        self,
        group_id: str,
        site_id: str,
        list_id: str,
        token: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function delta.
        OneDrive operation: GET /groups/{group-id}/sites/{site-id}/lists/{list-id}/items/delta(token='{token}')
        Operation type: discovery
        Args:
            group_id (str, required): OneDrive group id identifier
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            token (str, required): OneDrive path parameter: token
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).sites.by_site_id(site_id).lists.by_list_id(list_id).items.delta(token='{token}').get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_site_lists_list_items_delta_fa14(
        self,
        site_id: str,
        list_id: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function delta.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/delta()
        Operation type: discovery
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.delta().get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def sites_site_lists_list_items_delta_9846(
        self,
        site_id: str,
        list_id: str,
        token: str,
        dollar_select: Optional[List[str]] = None,
        dollar_orderby: Optional[List[str]] = None,
        dollar_expand: Optional[List[str]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Invoke function delta.
        OneDrive operation: GET /sites/{site-id}/lists/{list-id}/items/delta(token='{token}')
        Operation type: discovery
        Args:
            site_id (str, required): OneDrive site id identifier
            list_id (str, required): OneDrive list id identifier
            token (str, required): OneDrive path parameter: token
            dollar_select (List[str], optional): Select properties to be returned
            dollar_orderby (List[str], optional): Order items by property values
            dollar_expand (List[str], optional): Expand related entities
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., children, permissions)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for files and folders by name/content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OneDriveResponse: OneDrive response wrapper with success/data/error
        """
        # Build query parameters including OData for OneDrive
        try:
            # Use typed query parameters
            query_params = RequestConfiguration()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = orderby if isinstance(orderby, list) else [orderby]
            if search:
                query_params.search = search
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            # Create proper typed request configuration
            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            # Add consistency level for search operations in OneDrive
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.sites.by_site_id(site_id).lists.by_list_id(list_id).items.delta(token='{token}').get(request_configuration=config)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def drives_items_upload_content(
        self,
        drive_id: str,
        driveItem_id: str,
        content: bytes = b"",
        content_type: str = "application/octet-stream",
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        try:
            config = RequestConfiguration()
            config.headers.add("Content-Type", content_type)
            if headers:
                for k, v in headers.items():
                    config.headers.add(k, v)

            response = await self.client.drives.by_drive_id(drive_id)\
                .items.by_drive_item_id(driveItem_id)\
                .content.put(body=content, request_configuration=config)

            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(success=False, error=f"OneDrive API call failed: {str(e)}")

    async def drives_items_get_content(
        self,
        drive_id: str,
        driveItem_id: str,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """Download raw bytes content of a file.
        OneDrive operation: GET /drives/{drive-id}/items/{driveItem-id}/content
        """
        try:
            config = RequestConfiguration()
            if headers:
                for k, v in headers.items():
                    config.headers.add(k, v)

            raw: bytes = await self.client.drives.by_drive_id(drive_id)\
                .items.by_drive_item_id(driveItem_id)\
                .content.get(request_configuration=config)

            return OneDriveResponse(success=True, data=raw)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}",
            )

    async def me_followed_sites_shared_files(
        self,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """
        Fetch files from SharePoint / Teams sites the user follows.
        Covers Step 3–5 of Shared-with-me aggregation.

        APIs used:
        GET /me/followedSites
        GET /sites/{site-id}/drive
        GET /drives/{drive-id}/root/children
        """

        try:

            results = []

            # Step 3 — get followed SharePoint sites
            sites_response = await self.client.me.followed_sites.get()

            if not sites_response or not sites_response.value:
                return OneDriveResponse(success=True, data={"items": []})

            for site in sites_response.value:

                # Step 4 — get site drive
                drive = await self.client.sites.by_site_id(site.id).drive.get()

                if not drive or not drive.id:
                    continue

                # Step 5 — get root files of the site drive
                children = await self.client.drives.by_drive_id(drive.id)\
                    .root.children.get()

                if children and children.value:
                    for item in children.value:
                        results.append(item)

            return OneDriveResponse(
                success=True,
                data={"items": results}
            )

        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneDrive API call failed: {str(e)}"
            )

    async def me_onenote_create_notebooks(
        self,
        request_body: Optional[Mapping[str, Any]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """
        Create a new OneNote notebook.
        Operation: POST /me/onenote/notebooks
        """
        try:
            body = Notebook()
            if isinstance(request_body, dict):
                body.display_name = request_body.get("displayName")

            config = RequestConfiguration()
            config.headers.add("Content-Type", "application/json")
            if headers:
                for k, v in headers.items():
                    config.headers.add(k, v)

            response = await self.client.me.onenote.notebooks.post(
                body=body,
                request_configuration=config
            )
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneNote API call failed: {str(e)}",
            )
    
    async def drives_items_invite(
        self,
        drive_id: str,
        driveItem_id: str,
        request_body: Dict[str, Any]
    ) -> OneDriveResponse:
        try:
            response = await self.client.drives \
                .by_drive_id(drive_id) \
                .items.by_drive_item_id(driveItem_id) \
                .invite.post(body=request_body)

            return self._handle_onedrive_response(response)

        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"Invite failed: {str(e)}"
            )

    async def me_onenote_create_section(
        self,
        notebook_id: str,
        display_name: str,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """
        Create a new section in an existing OneNote notebook.
        Operation: POST /me/onenote/notebooks/{notebook_id}/sections
        """
        try:
            body = OnenoteSection()
            body.display_name = display_name

            config = RequestConfiguration()
            config.headers.add("Content-Type", "application/json")
            if headers:
                for k, v in headers.items():
                    config.headers.add(k, v)

            response = await self.client.me.onenote.notebooks.by_notebook_id(
                notebook_id
            ).sections.post(
                body=body,
                request_configuration=config
            )
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneNote API call failed: {str(e)}",
            )

    async def me_onenote_create_page(
        self,
        section_id: str,
        title: str,
        body_html: str = "",
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OneDriveResponse:
        """
        Create a new page in an existing OneNote section.
        Operation: POST /me/onenote/sections/{section_id}/pages

        The Graph SDK's pages.post() expects a Parsable object, but the
        OneNote API requires raw HTML with Content-Type: text/html.
        We use the request adapter's send_async with a native RequestInformation.
        """
        try:
            from msgraph.generated.models.onenote_page import OnenotePage

            html = (
                f"<!DOCTYPE html>\n"
                f"<html>\n"
                f"  <head><title>{title}</title></head>\n"
                f"  <body>{body_html}</body>\n"
                f"</html>"
            )

            request_info = RequestInformation()
            request_info.http_method = Method.POST
            request_info.url = (
                f"https://graph.microsoft.com/v1.0"
                f"/me/onenote/sections/{urllib.parse.quote(section_id, safe='')}/pages"
            )
            request_info.headers.try_add("Content-Type", "text/html")
            request_info.set_stream_content(html.encode("utf-8"))

            response = await self.client.request_adapter.send_async(
                request_info,
                OnenotePage,
                None,
            )
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneNote API call failed: {str(e)}",
            )

    async def me_onenote_get_notebook_from_web_url(
        self,
        web_url: str,
        **kwargs
    ) -> OneDriveResponse:
        """
        Resolve a OneNote notebook from its webUrl.
        Operation: POST /me/onenote/notebooks/getNotebookFromWebUrl
        """
        try:
            from msgraph.generated.users.item.onenote.notebooks.get_notebook_from_web_url.get_notebook_from_web_url_post_request_body import (
                GetNotebookFromWebUrlPostRequestBody,
            )

            body = GetNotebookFromWebUrlPostRequestBody(web_url=web_url)
            response = await self.client.me.onenote.notebooks \
                .get_notebook_from_web_url \
                .post(body)
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneNote API call failed: {str(e)}",
            )

    async def me_onenote_get_sections(
        self,
        notebook_id: str,
        **kwargs
    ) -> OneDriveResponse:
        """
        List all sections in a OneNote notebook.
        Operation: GET /me/onenote/notebooks/{notebook_id}/sections
        """
        try:
            response = await self.client.me.onenote.notebooks.by_notebook_id(
                notebook_id
            ).sections.get()
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneNote API call failed: {str(e)}",
            )

    async def me_onenote_get_pages(
        self,
        section_id: str,
        **kwargs
    ) -> OneDriveResponse:
        """
        List all pages in a OneNote section.
        Operation: GET /me/onenote/sections/{section_id}/pages
        """
        try:
            response = await self.client.me.onenote.sections.by_onenote_section_id(
                section_id
            ).pages.get()
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneNote API call failed: {str(e)}",
            )

    async def me_onenote_get_page_content(
        self,
        page_id: str,
        **kwargs
    ) -> OneDriveResponse:
        """
        Get the HTML content of a OneNote page.
        Operation: GET /me/onenote/pages/{page_id}/content

        The SDK does not expose a clean helper for /content,
        so we use the request adapter directly.
        """
        try:
            request_info = RequestInformation()
            request_info.http_method = Method.GET
            request_info.url = (
                f"https://graph.microsoft.com/v1.0"
                f"/me/onenote/pages/{urllib.parse.quote(page_id, safe='')}/content"
            )

            response = await self.client.request_adapter.send_primitive_async(
                request_info,
                "bytes",
                None,
            )
            if response:
                html_text = response.decode("utf-8") if isinstance(response, bytes) else str(response)
                return OneDriveResponse(success=True, data=html_text)
            return OneDriveResponse(success=False, error="Empty response from OneNote API")
        except Exception as e:
            return OneDriveResponse(
                success=False,
                error=f"OneNote API call failed: {str(e)}",
            )

    async def me(self) -> OneDriveResponse:
        try:
            response = await self.client.me.get()
            return self._handle_onedrive_response(response)
        except Exception as e:
            return OneDriveResponse(success=False, error=str(e))