

import json
import logging
from dataclasses import asdict
from datetime import date
from typing import Any, Dict, List, Literal, Mapping, Optional

from app.connectors.sources.microsoft.common.constants import escape_odata_string
from app.sources.client.microsoft.microsoft import MSGraphClient
from kiota_abstractions.base_request_configuration import (  # type: ignore
    RequestConfiguration,
)
from kiota_abstractions.headers_collection import HeadersCollection
from msgraph.generated.models.attachment import Attachment  # type: ignore
from msgraph.generated.models.attendee import Attendee  # type: ignore
from msgraph.generated.models.attendee_type import AttendeeType  # type: ignore
from msgraph.generated.models.body_type import BodyType  # type: ignore
from msgraph.generated.models.conversation_thread import (
    ConversationThread,  # type: ignore
)
from msgraph.generated.models.date_time_time_zone import (
    DateTimeTimeZone,  # type: ignore
)
from msgraph.generated.models.email_address import EmailAddress  # type: ignore
from msgraph.generated.models.event import Event  # type: ignore
from msgraph.generated.models.group import Group  # type: ignore
from msgraph.generated.models.item_body import ItemBody  # type: ignore
from msgraph.generated.models.location import Location  # type: ignore
from msgraph.generated.models.mail_folder import MailFolder  # type: ignore
from msgraph.generated.models.message import Message  # type: ignore
from msgraph.generated.models.patterned_recurrence import PatternedRecurrence
from msgraph.generated.models.post import Post  # type: ignore
from msgraph.generated.models.recipient import Recipient  # type: ignore
from msgraph.generated.models.recurrence_pattern import RecurrencePattern
from msgraph.generated.models.recurrence_pattern_type import RecurrencePatternType
from msgraph.generated.models.recurrence_range import RecurrenceRange
from msgraph.generated.models.recurrence_range_type import RecurrenceRangeType
from msgraph.generated.models.user import User  # type: ignore
from msgraph.generated.users.item.calendar.calendar_view.calendar_view_request_builder import (  # type: ignore
    CalendarViewRequestBuilder,
)
from msgraph.generated.users.item.calendars.calendars_request_builder import (  # type: ignore
    CalendarsRequestBuilder,
)
from msgraph.generated.users.item.contact_folders.contact_folders_request_builder import (  # type: ignore
    ContactFoldersRequestBuilder,
)
from msgraph.generated.users.item.contacts.contacts_request_builder import (  # type: ignore
    ContactsRequestBuilder,
)
from msgraph.generated.users.item.events.events_request_builder import (  # type: ignore
    EventsRequestBuilder,
)
from msgraph.generated.users.item.events.item.instances.instances_request_builder import (
    InstancesRequestBuilder,
)
from msgraph.generated.users.item.mail_folders.item.messages.delta.delta_request_builder import (  # type: ignore
    DeltaRequestBuilder,
)
from msgraph.generated.users.item.mail_folders.mail_folders_request_builder import (  # type: ignore
    MailFoldersRequestBuilder,
)
from msgraph.generated.users.item.messages.item.forward.forward_post_request_body import (
    ForwardPostRequestBody,  # type: ignore
)
from msgraph.generated.users.item.messages.item.reply.reply_post_request_body import (
    ReplyPostRequestBody,  # type: ignore
)
from msgraph.generated.users.item.messages.item.reply_all.reply_all_post_request_body import (
    ReplyAllPostRequestBody,  # type: ignore
)

# Import MS Graph specific query parameter classes for Outlook
from msgraph.generated.users.item.messages.messages_request_builder import (  # type: ignore
    MessagesRequestBuilder,
)


# Outlook-specific response wrapper
class OutlookCalendarContactsResponse:
    """Standardized Outlook API response wrapper.
    
    For collection responses, data is a dict with structure:
    {
        'value': List[Message | User | Group | Event | Attachment | Post | ConversationThread | ...],
        'odata_next_link': Optional[str],
        'odata_delta_link': Optional[str]
    }
    
    For single entity responses, data is the Pydantic object itself (Message, User, etc.)
    """
    success: bool
    data: Optional[Dict[str, Any] | Message | User | Group | Event | Attachment | Post | ConversationThread] = None
    error: Optional[str] = None
    message: Optional[str] = None

    def __init__(self, success: bool, data: Optional[Dict[str, Any] | Message | User | Group | Event | Attachment | Post | ConversationThread] = 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]:
        return asdict(self)

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

# Outlook-specific response wrapper for mail folders
class OutlookMailFoldersResponse:
    """Standardized Outlook Mail Folders API response wrapper.
    
    For mail folders, data is a dict with structure:
    {
        'value': List[Dict[str, Any]],  # MailFolder objects converted to dicts
        '@odata.nextLink': Optional[str],
        'count': int
    }
    
    Note: Unlike other responses, mail folders are converted to dicts by _handle_mail_folders_response
    """
    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]:
        return asdict(self)

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

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



def _dict_to_message(data: dict) -> Message:
    """Convert a message dict to a typed Message SDK object."""
    msg = Message()

    if "subject" in data:
        msg.subject = data["subject"]

    if "body" in data:
        body_data = data["body"]
        body = ItemBody()
        content_type = body_data.get("contentType", "Text")
        body.content_type = BodyType.Html if content_type.lower() == "html" else BodyType.Text
        body.content = body_data.get("content", "")
        msg.body = body

    if "toRecipients" in data:
        msg.to_recipients = [_dict_to_recipient(r) for r in data["toRecipients"]]

    if "ccRecipients" in data:
        msg.cc_recipients = [_dict_to_recipient(r) for r in data["ccRecipients"]]

    if "bccRecipients" in data:
        msg.bcc_recipients = [_dict_to_recipient(r) for r in data["bccRecipients"]]

    return msg


def _dict_to_recipient(data: dict) -> Recipient:
    """Convert a recipient dict to a typed Recipient SDK object."""
    recipient = Recipient()
    email_data = data.get("emailAddress", {})
    email = EmailAddress()
    email.address = email_data.get("address")
    email.name = email_data.get("name")
    recipient.email_address = email
    return recipient


def _dict_to_event(data: dict) -> Event:
    """Convert an event dict to a typed Event SDK object."""
    event = Event()

    if "subject" in data:
        event.subject = data["subject"]

    if "body" in data:
        body_data = data["body"]
        body = ItemBody()
        content_type = body_data.get("contentType", "Text")
        body.content_type = BodyType.Html if content_type.lower() == "html" else BodyType.Text
        body.content = body_data.get("content", "")
        event.body = body

    if "start" in data:
        start = DateTimeTimeZone()
        start.date_time = data["start"].get("dateTime")
        start.time_zone = data["start"].get("timeZone", "UTC")
        event.start = start

    if "end" in data:
        end = DateTimeTimeZone()
        end.date_time = data["end"].get("dateTime")
        end.time_zone = data["end"].get("timeZone", "UTC")
        event.end = end

    if "location" in data:
        loc = Location()
        loc.display_name = data["location"].get("displayName")
        event.location = loc

    if "attendees" in data:
        attendees = []
        for att_data in data["attendees"]:
            att = Attendee()
            email = EmailAddress()
            email_data = att_data.get("emailAddress", {})
            email.address = email_data.get("address")
            email.name = email_data.get("name")
            att.email_address = email
            att_type = att_data.get("type", "required")
            att.type = AttendeeType.Required if att_type == "required" else AttendeeType.Optional
            attendees.append(att)
        event.attendees = attendees

    if "isOnlineMeeting" in data:
        event.is_online_meeting = data["isOnlineMeeting"]

    if "recurrence" in data:
        rec = data["recurrence"]
        if isinstance(rec, PatternedRecurrence):
            event.recurrence = rec
        elif isinstance(rec, dict):
            from datetime import date

            from msgraph.generated.models.day_of_week import DayOfWeek
            from msgraph.generated.models.week_index import WeekIndex

            def _to_date(val):
                if isinstance(val, date):
                    return val
                return date.fromisoformat(val)

            DAY_MAP = {
                "sunday":    DayOfWeek.Sunday,
                "monday":    DayOfWeek.Monday,
                "tuesday":   DayOfWeek.Tuesday,
                "wednesday": DayOfWeek.Wednesday,
                "thursday":  DayOfWeek.Thursday,
                "friday":    DayOfWeek.Friday,
                "saturday":  DayOfWeek.Saturday,
            }

            INDEX_MAP = {
                "first":  WeekIndex.First,
                "second": WeekIndex.Second,
                "third":  WeekIndex.Third,
                "fourth": WeekIndex.Fourth,
                "last":   WeekIndex.Last,
            }

            pattern_data = rec.get("pattern", {})
            range_data = rec.get("range", {})

            pattern = RecurrencePattern()
            pattern_type = pattern_data.get("type", "daily").lower()
            pattern.type = {
                "daily":           RecurrencePatternType.Daily,
                "weekly":          RecurrencePatternType.Weekly,
                "absolutemonthly": RecurrencePatternType.AbsoluteMonthly,
                "relativemonthly": RecurrencePatternType.RelativeMonthly,
                "absoluteyearly":  RecurrencePatternType.AbsoluteYearly,
                "relativeyearly":  RecurrencePatternType.RelativeYearly,
            }.get(pattern_type, RecurrencePatternType.Daily)

            # Common to all patterns
            pattern.interval = pattern_data.get("interval", 1)

            # Weekly / RelativeMonthly / RelativeYearly — requires daysOfWeek
            if "daysOfWeek" in pattern_data:
                pattern.days_of_week = [
                    DAY_MAP[d.lower()]
                    for d in pattern_data["daysOfWeek"]
                    if d.lower() in DAY_MAP
                ]

            # Weekly — optional first day of week (defaults to Sunday if omitted)
            if "firstDayOfWeek" in pattern_data:
                pattern.first_day_of_week = DAY_MAP.get(
                    pattern_data["firstDayOfWeek"].lower(), DayOfWeek.Sunday
                )

            # RelativeMonthly / RelativeYearly — which week in the month
            if "index" in pattern_data:
                pattern.index = INDEX_MAP.get(pattern_data["index"].lower())

            # AbsoluteMonthly / AbsoluteYearly — specific day of month (1–31)
            if "dayOfMonth" in pattern_data:
                pattern.day_of_month = pattern_data["dayOfMonth"]

            # AbsoluteYearly / RelativeYearly — specific month (1–12)
            if "month" in pattern_data:
                pattern.month = pattern_data["month"]

            # Build range
            range_ = RecurrenceRange()
            range_type = range_data.get("type", "endDate").lower()
            range_.type = {
                "enddate":  RecurrenceRangeType.EndDate,
                "noend":    RecurrenceRangeType.NoEnd,
                "numbered": RecurrenceRangeType.Numbered,
            }.get(range_type, RecurrenceRangeType.EndDate)

            range_.start_date = _to_date(range_data["startDate"])

            # EndDate range — requires endDate
            if "endDate" in range_data:
                range_.end_date = _to_date(range_data["endDate"])

            # Numbered range — requires numberOfOccurrences
            if "numberOfOccurrences" in range_data:
                range_.number_of_occurrences = range_data["numberOfOccurrences"]

            # Optional: recurrenceTimeZone for range
            if "recurrenceTimeZone" in range_data:
                range_.recurrence_time_zone = range_data["recurrenceTimeZone"]

            event.recurrence = PatternedRecurrence(pattern=pattern, range=range_)
    return event


class OutlookCalendarContactsDataSource:
    """
    Comprehensive Microsoft Outlook API client with complete Mail, Calendar, and Contacts coverage.

    Features:
    - Complete Outlook API coverage with 681 methods organized by operation type
    - Support for Personal and User Mail, Calendar, and Contacts
    - Group Calendar support for team scheduling
    - Complete Mail operations: messages, folders, attachments, rules, categories
    - Complete Calendar operations: events, calendars, calendar view, instances, recurring events
    - Complete Contact operations: contacts, contact folders, photos, extended properties
    - Search capabilities across mail, calendar, and contacts
    - Delta synchronization for efficient change tracking
    - Attachment handling for messages, events, and contacts
    - Extended properties support for custom data
    - Microsoft Graph SDK integration with Outlook-specific optimizations
    - Async snake_case method names for all operations
    - Standardized OutlookCalendarContactsResponse format for all responses
    - Comprehensive error handling and Outlook-specific response processing

    EXCLUDED OPERATIONS (modify EXCLUDED_KEYWORDS list to change):
    - OneDrive operations (drive, drives, items)
    - Teams operations (chats, teams, channels)
    - SharePoint operations (sites, lists, document libraries)
    - OneNote operations (notebooks, sections, pages)
    - Planner operations (plans, tasks, buckets)
    - Directory operations (directoryObjects, devices)
    - Admin operations (admin, compliance, security)
    - To-Do operations (todo lists and tasks)
    - Device management operations
    - Communications operations (communications, education, identity)
    - Education operations (education)
    - Identity operations (identity)
    - Photos operations (photos)

    Operation Types:
    - Mail operations: Messages, mail folders, message rules, categories
    - Calendar operations: Events, calendars, calendar view, instances
    - Contacts operations: Contacts, contact folders, photos
    - Attachments operations: File attachments for messages, events, contacts
    - Extensions operations: Custom properties and extended data
    - Rules operations: Mail rules and inference classification
    - Categories operations: Outlook categories and master categories
    - People operations: People suggestions and directory
    - Photos operations: Photos
    - General operations: Base Outlook functionality
    """

    def __init__(self, client: MSGraphClient) -> None:
        """Initialize with Microsoft Graph SDK client optimized for Outlook."""
        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("Outlook client initialized with 681 methods")

    def _handle_outlook_response(self, response: object) -> OutlookCalendarContactsResponse:
        """Handle Outlook API response with comprehensive error handling and pagination links."""
        try:
            if response is None:
                return OutlookCalendarContactsResponse(success=False, error="Empty response from Outlook API")

            success = True
            error_msg = None

            # Enhanced error response handling for Outlook 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 the response object as-is (Pydantic collection or single entity)
            return OutlookCalendarContactsResponse(
                success=success,
                data=response,
                error=error_msg,
            )
        except Exception as e:
            logger.error(f"Error handling Outlook response: {e}")
            return OutlookCalendarContactsResponse(success=False, error=str(e))

    def _handle_mail_folders_response(self, response: object) -> OutlookMailFoldersResponse:
        """Handle mail folders API response specifically."""
        try:
            if response is None:
                return OutlookMailFoldersResponse(success=False, error="Empty response from Outlook API")

            success = True
            error_msg = None

            # Handle error responses
            if hasattr(response, 'error'):
                success = False
                error_msg = str(response.error)

            # Return the response object as-is (MailFolderCollectionResponse)
            return OutlookMailFoldersResponse(
                success=success,
                data=response,
                error=error_msg,
                message=f"Successfully retrieved {len(response.value) if (response and hasattr(response, 'value') and response.value) else 0} mail folders" if success else None
            )

        except Exception as e:
            logger.error(f"Error handling mail folders response: {e}")
            return OutlookMailFoldersResponse(success=False, error=str(e))

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

    async def fetch_all_messages_delta(
        self,
        user_id: str,
        mailFolder_id: str,
        saved_delta_link: str | None = None,
        page_size: int = 200,
        **initial_params
    ) -> tuple[list[Message], str | None]:
        """Fetch all delta messages with automatic pagination.

        This method automatically handles pagination by following nextLink until
        a deltaLink is received, which indicates all changes have been retrieved.

        Args:
            user_id: User identifier
            mailFolder_id: Mail folder identifier
            saved_delta_link: Previously saved deltaLink for incremental sync
            page_size: Page size preference (default 200, max for messages)
            **initial_params: Additional parameters (select, expand, etc.) for initial request only

        Returns:
            Tuple of (all_messages, final_delta_link)
            - all_messages: List of all message changes
            - final_delta_link: New delta link to save for next incremental sync
        """
        all_messages = []
        continuation_url = saved_delta_link
        is_first_request = True

        logger.info(f"Starting delta fetch for user {user_id}, folder {mailFolder_id}")
        if saved_delta_link:
            logger.info("Using saved delta link for incremental sync")

        while True:
            # On first request without saved delta, use initial params
            if is_first_request and not continuation_url:
                response = await self.users_user_mail_folders_mail_folder_messages_delta(
                    user_id=user_id,
                    mailFolder_id=mailFolder_id,
                    continuation_url=None,
                    page_size=page_size,
                    **initial_params
                )
            else:
                # Use continuation URL (nextLink or deltaLink)
                response = await self.users_user_mail_folders_mail_folder_messages_delta(
                    user_id=user_id,
                    mailFolder_id=mailFolder_id,
                    continuation_url=continuation_url
                )

            is_first_request = False

            if not response.success:
                raise Exception(f"Delta query failed: {response.error}")

            # Collect messages from this page - response.data is MessageCollectionResponse
            messages = response.data.value if response.data.value else []
            all_messages.extend(messages)
            logger.info(f"Retrieved {len(messages)} messages in this page (total so far: {len(all_messages)})")

            # Check for next page or completion
            next_link = response.data.odata_next_link if response.data.odata_next_link else None
            delta_link = response.data.odata_delta_link if response.data.odata_delta_link else None

            if next_link:
                # More pages available
                logger.info("nextLink found, fetching next page...")
                continuation_url = next_link
                continue
            elif delta_link:
                # Sync complete - save this for next round
                logger.info(f"Delta sync complete. Total messages: {len(all_messages)}")
                return all_messages, delta_link
            else:
                raise Exception("Response missing both odata_next_link and odata_delta_link")

    async def fetch_all_messages_delta_me(
        self,
        mailFolder_id: str,
        saved_delta_link: str | None = None,
        page_size: int = 200,
        **initial_params
    ) -> tuple[list[Message], str | None]:
        """Fetch all delta messages for authenticated user (/me) with automatic pagination.

        This method automatically handles pagination by following nextLink until
        a deltaLink is received, which indicates all changes have been retrieved.

        Args:
            mailFolder_id: Mail folder identifier
            saved_delta_link: Previously saved deltaLink for incremental sync
            page_size: Page size preference (default 200, max for messages)
            **initial_params: Additional parameters (select, expand, etc.) for initial request only

        Returns:
            Tuple of (all_messages, final_delta_link)
            - all_messages: List of all message changes
            - final_delta_link: New delta link to save for next incremental sync
        """
        all_messages = []
        continuation_url = saved_delta_link
        is_first_request = True

        logger.info(f"Starting delta fetch for /me folder {mailFolder_id}")
        if saved_delta_link:
            logger.info("Using saved delta link for incremental sync")

        while True:
            # On first request without saved delta, use initial params
            if is_first_request and not continuation_url:
                response = await self.me_mail_folders_mail_folder_messages_delta(
                    mailFolder_id=mailFolder_id,
                    continuation_url=None,
                    page_size=page_size,
                    **initial_params
                )
            else:
                # Use continuation URL (nextLink or deltaLink)
                response = await self.me_mail_folders_mail_folder_messages_delta(
                    mailFolder_id=mailFolder_id,
                    continuation_url=continuation_url
                )

            is_first_request = False

            if not response.success:
                raise Exception(f"Delta query failed: {response.error}")

            # Collect messages from this page - response.data is MessageCollectionResponse
            messages = response.data.value if response.data.value else []
            all_messages.extend(messages)
            logger.info(f"Retrieved {len(messages)} messages in this page (total so far: {len(all_messages)})")

            # Check for next page or completion
            next_link = response.data.odata_next_link if response.data.odata_next_link else None
            delta_link = response.data.odata_delta_link if response.data.odata_delta_link else None

            if next_link:
                # More pages available
                logger.info("nextLink found, fetching next page...")
                continuation_url = next_link
                continue
            elif delta_link:
                # Sync complete - save this for next round
                logger.info(f"Delta sync complete. Total messages: {len(all_messages)}")
                return all_messages, delta_link
            else:
                raise Exception("Response missing both odata_next_link and odata_delta_link")

    # ========== MAIL OPERATIONS (217 methods) ==========

    async def employee_experience_communities_owners_get_mailbox_settings(
        self,
        community_id: str,
        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
    ) -> OutlookCalendarContactsResponse:
        """Get mailboxSettings property value.
        Outlook operation: GET /employeeExperience/communities/{community-id}/owners/{user-id}/mailboxSettings
        Operation type: mail
        Args:
            community_id (str, required): Outlook community id identifier
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.employee_experience.communities.by_communitie_id(community_id).owners.by_owner_id(user_id).mailbox_settings.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def employee_experience_communities_owners_update_mailbox_settings(
        self,
        community_id: str,
        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
    ) -> OutlookCalendarContactsResponse:
        """Update property mailboxSettings value..
        Outlook operation: PATCH /employeeExperience/communities/{community-id}/owners/{user-id}/mailboxSettings
        Operation type: mail
        Args:
            community_id (str, required): Outlook community id identifier
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.employee_experience.communities.by_communitie_id(community_id).owners.by_owner_id(user_id).mailbox_settings.patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_team_channels_create_messages(
        self,
        group_id: str,
        channel_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to messages for groups.
        Outlook operation: POST /groups/{group-id}/team/channels/{channel-id}/messages
        Operation type: mail
        Args:
            group_id (str, required): Outlook group id identifier
            channel_id (str, required): Outlook channel id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            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).messages.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_team_channels_list_messages(
        self,
        group_id: str,
        channel_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
    ) -> OutlookCalendarContactsResponse:
        """Get messages from groups.
        Outlook operation: GET /groups/{group-id}/team/channels/{channel-id}/messages
        Operation type: mail
        Args:
            group_id (str, required): Outlook group id identifier
            channel_id (str, required): Outlook channel 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            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).messages.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_team_primary_channel_create_messages(
        self,
        group_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to messages for groups.
        Outlook operation: POST /groups/{group-id}/team/primaryChannel/messages
        Operation type: mail
        Args:
            group_id (str, required): Outlook group id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            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.messages.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_team_primary_channel_list_messages(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get messages from groups.
        Outlook operation: GET /groups/{group-id}/team/primaryChannel/messages
        Operation type: mail
        Args:
            group_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            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.messages.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def invitations_invited_user_get_mailbox_settings(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get mailboxSettings property value.
        Outlook operation: GET /invitations/invitedUser/mailboxSettings
        Operation type: mail
        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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.invitations.invited_user.mailbox_settings.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def invitations_invited_user_update_mailbox_settings(
        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
    ) -> OutlookCalendarContactsResponse:
        """Update property mailboxSettings value..
        Outlook operation: PATCH /invitations/invitedUser/mailboxSettings
        Operation type: mail
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.invitations.invited_user.mailbox_settings.patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_create_mail_folders(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create MailFolder.
        Outlook operation: POST /me/mailFolders
        Operation type: mail
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_list_mail_folders(
        self,
        next_url: Optional[str] = None,
        includeHiddenFolders: Optional[str] = None,
        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
    ) -> OutlookCalendarContactsResponse:
        """List mailFolders.
        Outlook operation: GET /me/mailFolders
        Operation type: mail
        Args:
            next_url (str, optional): Full URL from @odata.nextLink for pagination
            includeHiddenFolders (str, optional): Include Hidden Folders
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            if next_url:
                # Use the complete URL from nextLink for pagination
                response = await self.client.me.mail_folders.with_url(next_url).get()
            else:
                # Use typed query parameters
                query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

                if headers:
                    config.headers = headers

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

                response = await self.client.me.mail_folders.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_delta(
        self,
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/mailFolders/delta()
        Operation type: mail
        Args:
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_delete_mail_folders(
        self,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Delete mailFolder.
        Outlook operation: DELETE /me/mailFolders/{mailFolder-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_get_mail_folders(
        self,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Get mailFolder.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_update_mail_folders(
        self,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Update mailSearchFolder.
        Outlook operation: PATCH /me/mailFolders/{mailFolder-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_create_child_folders(
        self,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Create mailSearchFolder.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_list_child_folders(
        self,
        mailFolder_id: str,
        includeHiddenFolders: Optional[str] = None,
        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
    ) -> OutlookCalendarContactsResponse:
        """List childFolders.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/childFolders
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            includeHiddenFolders (str, optional): Include Hidden Folders
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_delta(
        self,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/childFolders/delta()
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_delete_child_folders(
        self,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property childFolders for me.
        Outlook operation: DELETE /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_get_child_folders(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        includeHiddenFolders: Optional[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
    ) -> OutlookCalendarContactsResponse:
        """Get childFolders from me.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            includeHiddenFolders (str, optional): Include Hidden Folders
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_update_child_folders(
        self,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property childFolders in me.
        Outlook operation: PATCH /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_copy(
        self,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action copy.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/copy
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).copy.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_create_message_rules(
        self,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to messageRules for me.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messageRules
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).message_rules.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_list_message_rules(
        self,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Get messageRules from me.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messageRules
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).message_rules.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_delete_message_rules(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        messageRule_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property messageRules for me.
        Outlook operation: DELETE /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messageRules/{messageRule-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            messageRule_id (str, required): Outlook messageRule id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).message_rules.by_message_rule_id(messageRule_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_get_message_rules(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        messageRule_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
    ) -> OutlookCalendarContactsResponse:
        """Get messageRules from me.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messageRules/{messageRule-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            messageRule_id (str, required): Outlook messageRule 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).message_rules.by_message_rule_id(messageRule_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_update_message_rules(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        messageRule_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property messageRules in me.
        Outlook operation: PATCH /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messageRules/{messageRule-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            messageRule_id (str, required): Outlook messageRule id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).message_rules.by_message_rule_id(messageRule_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_create_messages(
        self,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to messages for me.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_list_messages(
        self,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Get messages from me.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_messages_delta(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        changeType: Optional[str] = None,
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/delta()
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            changeType (str, optional): A custom query option to filter the delta response based on the type of change. Supported values are created, updated or deleted.
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_delete_messages(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property messages for me.
        Outlook operation: DELETE /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_get_messages(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Get messages from me.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_update_messages(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property messages in me.
        Outlook operation: PATCH /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_delete_messages_content(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Delete media content for the navigation property messages in me.
        Outlook operation: DELETE /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/$value
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).value.delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_get_messages_content(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Get media content for the navigation property messages from me.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/$value
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).value.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_update_messages_content(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Update media content for the navigation property messages in me.
        Outlook operation: PUT /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/$value
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).value.put(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_messages_create_attachments(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for me.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/attachments
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_messages_list_attachments(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from me.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/attachments
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_messages_message_attachments_create_upload_session(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/attachments/createUploadSession
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_messages_delete_attachments(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for me.
        Outlook operation: DELETE /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/attachments/{attachment-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_child_folders_messages_get_attachments(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from me.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/attachments/{attachment-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_messages_message_copy(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action copy.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/copy
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).copy.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_messages_message_create_forward(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createForward.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/createForward
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).create_forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_messages_message_create_reply(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createReply.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/createReply
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).create_reply.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_messages_message_create_reply_all(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createReplyAll.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/createReplyAll
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).create_reply_all.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_messages_message_forward(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/forward
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_messages_message_move(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action move.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/move
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).move.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_messages_message_permanent_delete(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/permanentDelete
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_messages_message_reply(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action reply.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/reply
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).reply.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_messages_message_reply_all(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action replyAll.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/replyAll
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).reply_all.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_messages_message_send(
        self,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action send.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/send
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).send.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_move(
        self,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action move.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/move
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).move.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_child_folders_mail_folder_permanent_delete(
        self,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/permanentDelete
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_copy(
        self,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action copy.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/copy
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).copy.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_create_message_rules(
        self,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Create rule.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/messageRules
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).message_rules.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_list_message_rules(
        self,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """List rules.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/messageRules
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).message_rules.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_delete_message_rules(
        self,
        mailFolder_id: str,
        messageRule_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
    ) -> OutlookCalendarContactsResponse:
        """Delete messageRule.
        Outlook operation: DELETE /me/mailFolders/{mailFolder-id}/messageRules/{messageRule-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            messageRule_id (str, required): Outlook messageRule id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).message_rules.by_message_rule_id(messageRule_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_get_message_rules(
        self,
        mailFolder_id: str,
        messageRule_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
    ) -> OutlookCalendarContactsResponse:
        """Get rule.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/messageRules/{messageRule-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            messageRule_id (str, required): Outlook messageRule 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).message_rules.by_message_rule_id(messageRule_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_update_message_rules(
        self,
        mailFolder_id: str,
        messageRule_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
    ) -> OutlookCalendarContactsResponse:
        """Update rule.
        Outlook operation: PATCH /me/mailFolders/{mailFolder-id}/messageRules/{messageRule-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            messageRule_id (str, required): Outlook messageRule id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).message_rules.by_message_rule_id(messageRule_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_create_messages(
        self,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Create message in a mailfolder.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/messages
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_list_messages(
        self,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """List messages.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/messages
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_messages_delta(
        self,
        mailFolder_id: str,
        continuation_url: Optional[str] = None,
        page_size: Optional[int] = None,
        changeType: Optional[str] = None,
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta with pagination support.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/messages/delta()
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            continuation_url (str, optional): Complete nextLink or deltaLink URL from previous response
            page_size (int, optional): Preferred page size (max 200 for messages)
            changeType (str, optional): A custom query option to filter the delta response based on the type of change. Supported values are created, updated or deleted.
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error including pagination links
        """
        # Build query parameters including OData for Outlook
        try:
            if continuation_url:
                # Use the complete URL from nextLink or deltaLink
                response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.delta.with_url(continuation_url).get()
            else:
                # Create query parameters object
                from msgraph.generated.users.item.mail_folders.item.messages.delta.delta_request_builder import (
                    DeltaRequestBuilder,
                )
                query_params = DeltaRequestBuilder.DeltaRequestBuilderGetQueryParameters()

                # Set query parameters
                if select:
                    query_params.select = select if isinstance(select, list) else [select]
                if expand:
                    query_params.expand = expand if isinstance(expand, list) else [expand]
                if filter:
                    query_params.filter = filter
                if orderby:
                    query_params.orderby = orderby
                if search:
                    query_params.search = search

                # Create request configuration with query parameters using typed class
                request_configuration = DeltaRequestBuilder.DeltaRequestBuilderGetRequestConfiguration(
                    query_parameters=query_params
                )

                # Build headers
                from kiota_abstractions.headers_collection import HeadersCollection
                headers_col = HeadersCollection()
                
                if page_size:
                    headers_col.try_add("Prefer", f"odata.maxpagesize={page_size}")
                
                if search:
                    headers_col.try_add("ConsistencyLevel", "eventual")
                
                if headers:
                    for hk, hv in headers.items():
                        headers_col.try_add(hk, hv)
                
                request_configuration.headers = headers_col

                response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.delta.get(request_configuration=request_configuration)
            
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_delete_messages(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property messages for me.
        Outlook operation: DELETE /me/mailFolders/{mailFolder-id}/messages/{message-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_get_messages(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Get messages from me.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/messages/{message-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_update_messages(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property messages in me.
        Outlook operation: PATCH /me/mailFolders/{mailFolder-id}/messages/{message-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_delete_messages_content(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Delete media content for the navigation property messages in me.
        Outlook operation: DELETE /me/mailFolders/{mailFolder-id}/messages/{message-id}/$value
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).value.delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_get_messages_content(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """List messages.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/messages/{message-id}/$value
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).value.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_update_messages_content(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Update media content for the navigation property messages in me.
        Outlook operation: PUT /me/mailFolders/{mailFolder-id}/messages/{message-id}/$value
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).value.put(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_messages_create_attachments(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for me.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/messages/{message-id}/attachments
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_messages_list_attachments(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from me.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/messages/{message-id}/attachments
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_messages_message_attachments_create_upload_session(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/messages/{message-id}/attachments/createUploadSession
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_messages_delete_attachments(
        self,
        mailFolder_id: str,
        message_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for me.
        Outlook operation: DELETE /me/mailFolders/{mailFolder-id}/messages/{message-id}/attachments/{attachment-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_messages_get_attachments(
        self,
        mailFolder_id: str,
        message_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from me.
        Outlook operation: GET /me/mailFolders/{mailFolder-id}/messages/{message-id}/attachments/{attachment-id}
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_messages_message_copy(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action copy.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/messages/{message-id}/copy
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).copy.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_messages_message_create_forward(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createForward.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/messages/{message-id}/createForward
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).create_forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_messages_message_create_reply(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createReply.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/messages/{message-id}/createReply
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).create_reply.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_messages_message_create_reply_all(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createReplyAll.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/messages/{message-id}/createReplyAll
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).create_reply_all.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_messages_message_forward(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/messages/{message-id}/forward
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_messages_message_move(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action move.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/messages/{message-id}/move
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).move.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_messages_message_permanent_delete(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/messages/{message-id}/permanentDelete
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_messages_message_reply(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action reply.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/messages/{message-id}/reply
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).reply.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_messages_message_reply_all(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action replyAll.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/messages/{message-id}/replyAll
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).reply_all.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_messages_message_send(
        self,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action send.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/messages/{message-id}/send
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).send.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_move(
        self,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action move.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/move
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).move.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_mail_folders_mail_folder_permanent_delete(
        self,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/mailFolders/{mailFolder-id}/permanentDelete
        Operation type: mail
        Args:
            mailFolder_id (str, required): Outlook mailFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mail_folders.by_mail_folder_id(mailFolder_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_update_mailbox_settings(
        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
    ) -> OutlookCalendarContactsResponse:
        """Update user mailbox settings.
        Outlook operation: PATCH /me/mailboxSettings
        Operation type: mail
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.mailbox_settings.patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_create_messages(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create message (draft).
        Outlook operation: POST /me/messages
        """
        try:
            config = RequestConfiguration()
            if headers:
                config.headers = headers

            # Convert dict body to typed Message object (SDK requires .serialize())
            body = request_body
            if isinstance(request_body, dict):
                body = _dict_to_message(request_body)

            response = await self.client.me.messages.post(body=body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_list_messages(
        self,
        includeHiddenMessages: Optional[str] = None,
        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
    ) -> OutlookCalendarContactsResponse:
        """Get messages from the current user.
        Outlook operation: GET /me/messages
        Operation type: mail
        Args:
            includeHiddenMessages (str, optional): Include Hidden Messages
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Normalize empty strings to None for optional parameters
            filter = filter if filter and filter.strip() else None
            search = search if search and search.strip() else None
            orderby = orderby if orderby and orderby.strip() else None

            # Use typed query parameters
            query_params = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters()

            # Set query parameters using typed object properties
            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if search:
                # $search is mutually exclusive with $filter and $orderby in Graph API
                query_params.search = search
            else:
                if filter:
                    query_params.filter = filter
                if orderby:
                    query_params.orderby = orderby
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

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

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

            if search:
                config.headers.try_add('ConsistencyLevel', 'eventual')

            # Verify client has me property before making the call
            if not hasattr(self.client, 'me'):
                raise AttributeError("Graph client does not have 'me' property. Client may not be properly initialized for delegated authentication.")
            
            if not hasattr(self.client.me, 'messages'):
                raise AttributeError("Graph client 'me' does not have 'messages' property. This may indicate a permissions or configuration issue.")

            response = await self.client.me.messages.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except AttributeError as ae:
            logger.error(f"Attribute error in me_list_messages: {str(ae)}")
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook client configuration error: {str(ae)}. Please verify the client is properly initialized for delegated authentication.",
            )
        except Exception as e:
            error_msg = str(e)
            error_type = type(e).__name__
            logger.error(f"Error in me_list_messages ({error_type}): {error_msg}")
            # Include more context in error message for debugging
            if "404" in error_msg or "not found" in error_msg.lower():
                return OutlookCalendarContactsResponse(
                    success=False,
                    error=f"Outlook API endpoint not found (404). This may indicate: 1) The user doesn't have a mailbox, 2) Mail.Read or Mail.ReadWrite permissions are missing, 3) The Graph API endpoint is not accessible. Original error: {error_msg}",
                )
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {error_msg}",
            )


    async def me_get_message(
        self,
        message_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        """Get a specific message by ID.
        Outlook operation: GET /me/messages/{message-id}
        """
        try:
            query_params = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters()

            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 = MessagesRequestBuilder.MessagesRequestBuilderGetRequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

            response = await self.client.me.messages.by_message_id(message_id).get(
                request_configuration=config
            )
            return self._handle_outlook_response(response)
        except Exception as e:
            error_msg = str(e)
            error_type = type(e).__name__
            logger.error(f"Error in me_get_messages ({error_type}): {error_msg}")
            if "404" in error_msg or "not found" in error_msg.lower():
                return OutlookCalendarContactsResponse(
                    success=False,
                    error=f"Message not found (404). The message ID '{message_id}' may be invalid or deleted. Original error: {error_msg}",
                )
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {error_msg}",
            )

    async def me_messages_delta(
        self,
        changeType: Optional[str] = None,
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/messages/delta()
        Operation type: mail
        Args:
            changeType (str, optional): A custom query option to filter the delta response based on the type of change. Supported values are created, updated or deleted.
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.messages.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_delete_messages(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Delete eventMessage.
        Outlook operation: DELETE /me/messages/{message-id}
        Operation type: mail
        Args:
            message_id (str, required): Outlook message id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.messages.by_message_id(message_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_update_messages(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Update message.
        Outlook operation: PATCH /me/messages/{message-id}
        Operation type: mail
        Args:
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.messages.by_message_id(message_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_delete_messages_content(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Delete eventMessage.
        Outlook operation: DELETE /me/messages/{message-id}/$value
        Operation type: mail
        Args:
            message_id (str, required): Outlook message id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.messages.by_message_id(message_id).value.delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_update_messages_content(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Update message.
        Outlook operation: PUT /me/messages/{message-id}/$value
        Operation type: mail
        Args:
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.messages.by_message_id(message_id).value.put(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_create_attachments(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Add attachment.
        Outlook operation: POST /me/messages/{message-id}/attachments
        Operation type: mail
        Args:
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.messages.by_message_id(message_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_list_attachments(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """List attachments.
        Outlook operation: GET /me/messages/{message-id}/attachments
        Operation type: mail
        Args:
            message_id (str, required): Outlook message 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.messages.by_message_id(message_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_message_attachments_create_upload_session(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /me/messages/{message-id}/attachments/createUploadSession
        Operation type: mail
        Args:
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.messages.by_message_id(message_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_delete_attachments(
        self,
        message_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for me.
        Outlook operation: DELETE /me/messages/{message-id}/attachments/{attachment-id}
        Operation type: mail
        Args:
            message_id (str, required): Outlook message id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.messages.by_message_id(message_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_get_attachments(
        self,
        message_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachment.
        Outlook operation: GET /me/messages/{message-id}/attachments/{attachment-id}
        Operation type: mail
        Args:
            message_id (str, required): Outlook message id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.messages.by_message_id(message_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_message_copy(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action copy.
        Outlook operation: POST /me/messages/{message-id}/copy
        Operation type: mail
        Args:
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.messages.by_message_id(message_id).copy.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_message_create_forward(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createForward.
        Outlook operation: POST /me/messages/{message-id}/createForward
        Operation type: mail
        Args:
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.messages.by_message_id(message_id).create_forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_message_create_reply(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createReply.
        Outlook operation: POST /me/messages/{message-id}/createReply
        Operation type: mail
        Args:
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.messages.by_message_id(message_id).create_reply.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_message_create_reply_all(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createReplyAll.
        Outlook operation: POST /me/messages/{message-id}/createReplyAll
        Operation type: mail
        Args:
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.messages.by_message_id(message_id).create_reply_all.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_message_forward(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Forward a message.
        Outlook operation: POST /me/messages/{message-id}/forward
        """
        try:
            config = RequestConfiguration()
            if headers:
                config.headers = headers

            # Convert dict to typed ForwardPostRequestBody
            body = request_body
            if isinstance(request_body, dict):
                body = ForwardPostRequestBody()
                if "comment" in request_body:
                    body.comment = request_body["comment"]
                if "toRecipients" in request_body:
                    body.to_recipients = [_dict_to_recipient(r) for r in request_body["toRecipients"]]

            response = await self.client.me.messages.by_message_id(message_id).forward.post(
                body=body, request_configuration=config
            )
            # Forward operations return None/empty response on success (202 Accepted)
            if response is None:
                return OutlookCalendarContactsResponse(
                    success=True,
                    data={"message": "Message forwarded successfully", "message_id": message_id},
                )
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_message_move(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action move.
        Outlook operation: POST /me/messages/{message-id}/move
        Operation type: mail
        Args:
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.messages.by_message_id(message_id).move.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_message_permanent_delete(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/messages/{message-id}/permanentDelete
        Operation type: mail
        Args:
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.messages.by_message_id(message_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_message_reply(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Reply to a message.
        Outlook operation: POST /me/messages/{message-id}/reply
        """
        try:
            config = RequestConfiguration()
            if headers:
                config.headers = headers

            # Convert dict to typed ReplyPostRequestBody
            body = request_body
            if isinstance(request_body, dict):
                body = ReplyPostRequestBody()
                if "comment" in request_body:
                    body.comment = request_body["comment"]
                if "message" in request_body:
                    body.message = _dict_to_message(request_body["message"])

            response = await self.client.me.messages.by_message_id(message_id).reply.post(
                body=body, request_configuration=config
            )
            # Reply operations return None/empty response on success (202 Accepted)
            if response is None:
                return OutlookCalendarContactsResponse(
                    success=True,
                    data={"message": "Reply sent successfully", "message_id": message_id},
                )
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_message_reply_all(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Reply-all to a message.
        Outlook operation: POST /me/messages/{message-id}/replyAll
        """
        try:
            config = RequestConfiguration()
            if headers:
                config.headers = headers

            # Convert dict to typed ReplyAllPostRequestBody
            body = request_body
            if isinstance(request_body, dict):
                body = ReplyAllPostRequestBody()
                if "comment" in request_body:
                    body.comment = request_body["comment"]
                if "message" in request_body:
                    body.message = _dict_to_message(request_body["message"])

            response = await self.client.me.messages.by_message_id(message_id).reply_all.post(
                body=body, request_configuration=config
            )
            # Reply-all operations return None/empty response on success (202 Accepted)
            if response is None:
                return OutlookCalendarContactsResponse(
                    success=True,
                    data={"message": "Reply-all sent successfully", "message_id": message_id},
                )
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_messages_message_send(
        self,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Send a draft message.
        Outlook operation: POST /me/messages/{message-id}/send
        
        Note: The Graph API returns 202 Accepted with no response body for send operations.
        A None response indicates success, not failure.
        """
        try:
            config = RequestConfiguration()
            if headers:
                config.headers = headers

            response = await self.client.me.messages.by_message_id(message_id).send.post(
                request_configuration=config
            )
            # Send operations return None/empty response on success (202 Accepted)
            # This is expected behavior, not an error
            if response is None:
                return OutlookCalendarContactsResponse(
                    success=True,
                    data={"message": "Email sent successfully", "message_id": message_id},
                )
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_presence_set_status_message(
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action setStatusMessage.
        Outlook operation: POST /me/presence/setStatusMessage
        Operation type: mail
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.presence.set_status_message.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def print_shares_allowed_users_get_mailbox_settings(
        self,
        printerShare_id: str,
        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
    ) -> OutlookCalendarContactsResponse:
        """Get mailboxSettings property value.
        Outlook operation: GET /print/shares/{printerShare-id}/allowedUsers/{user-id}/mailboxSettings
        Operation type: mail
        Args:
            printerShare_id (str, required): Outlook printerShare id identifier
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.print.shares.by_share_id(printerShare_id).allowed_users.by_allowedUser_id(user_id).mailbox_settings.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def print_shares_allowed_users_update_mailbox_settings(
        self,
        printerShare_id: str,
        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
    ) -> OutlookCalendarContactsResponse:
        """Update property mailboxSettings value..
        Outlook operation: PATCH /print/shares/{printerShare-id}/allowedUsers/{user-id}/mailboxSettings
        Operation type: mail
        Args:
            printerShare_id (str, required): Outlook printerShare id identifier
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.print.shares.by_share_id(printerShare_id).allowed_users.by_allowedUser_id(user_id).mailbox_settings.patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def privacy_subject_rights_requests_approvers_get_mailbox_settings(
        self,
        subjectRightsRequest_id: str,
        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
    ) -> OutlookCalendarContactsResponse:
        """Get mailboxSettings property value.
        Outlook operation: GET /privacy/subjectRightsRequests/{subjectRightsRequest-id}/approvers/{user-id}/mailboxSettings
        Operation type: mail
        Args:
            subjectRightsRequest_id (str, required): Outlook subjectRightsRequest id identifier
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.privacy.subject_rights_requests.by_subjectRightsRequest_id(subjectRightsRequest_id).approvers.by_approver_id(user_id).mailbox_settings.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def privacy_subject_rights_requests_approvers_update_mailbox_settings(
        self,
        subjectRightsRequest_id: str,
        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
    ) -> OutlookCalendarContactsResponse:
        """Update property mailboxSettings value..
        Outlook operation: PATCH /privacy/subjectRightsRequests/{subjectRightsRequest-id}/approvers/{user-id}/mailboxSettings
        Operation type: mail
        Args:
            subjectRightsRequest_id (str, required): Outlook subjectRightsRequest id identifier
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.privacy.subject_rights_requests.by_subjectRightsRequest_id(subjectRightsRequest_id).approvers.by_approver_id(user_id).mailbox_settings.patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def privacy_subject_rights_requests_collaborators_get_mailbox_settings(
        self,
        subjectRightsRequest_id: str,
        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
    ) -> OutlookCalendarContactsResponse:
        """Get mailboxSettings property value.
        Outlook operation: GET /privacy/subjectRightsRequests/{subjectRightsRequest-id}/collaborators/{user-id}/mailboxSettings
        Operation type: mail
        Args:
            subjectRightsRequest_id (str, required): Outlook subjectRightsRequest id identifier
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.privacy.subject_rights_requests.by_subjectRightsRequest_id(subjectRightsRequest_id).collaborators.by_collaborator_id(user_id).mailbox_settings.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def privacy_subject_rights_requests_collaborators_update_mailbox_settings(
        self,
        subjectRightsRequest_id: str,
        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
    ) -> OutlookCalendarContactsResponse:
        """Update property mailboxSettings value..
        Outlook operation: PATCH /privacy/subjectRightsRequests/{subjectRightsRequest-id}/collaborators/{user-id}/mailboxSettings
        Operation type: mail
        Args:
            subjectRightsRequest_id (str, required): Outlook subjectRightsRequest id identifier
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.privacy.subject_rights_requests.by_subjectRightsRequest_id(subjectRightsRequest_id).collaborators.by_collaborator_id(user_id).mailbox_settings.patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def reports_get_mailbox_usage_detail(
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function getMailboxUsageDetail.
        Outlook operation: GET /reports/getMailboxUsageDetail(period='{period}')
        Operation type: mail
        Args:
            period (str, required): Outlook path parameter: period
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

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

    async def users_create_mail_folders(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to mailFolders for users.
        Outlook operation: POST /users/{user-id}/mailFolders
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_list_mail_folders(
        self,
        user_id: str,
        next_url: Optional[str] = None,
        folder_names: Optional[List[str]] = None,
        folder_filter_mode: Optional[Literal["include", "exclude"]] = "include",
        includeHiddenFolders: Optional[str] = None,
        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
    ) -> OutlookMailFoldersResponse:
        """Get mailFolders from users.
        Outlook operation: GET /users/{user-id}/mailFolders
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            next_url (str, optional): Full URL from @odata.nextLink for pagination
            folder_names (List[str], optional): List of folder display names to filter
            folder_filter_mode (str, optional): 'include' to whitelist or 'exclude' to blacklist folder_names
            includeHiddenFolders (str, optional): Include Hidden Folders
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax (overridden if folder_names provided)
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            if next_url:
                # Use the complete URL from nextLink for pagination
                response = await self.client.users.by_user_id(user_id).mail_folders.with_url(next_url).get()
            else:
                # Build filter string from folder_names if provided
                # Note: MS Graph mailFolders doesn't support 'in' operator, use 'eq' with 'or' instead
                if folder_names and folder_filter_mode:
                    if folder_filter_mode.lower() == 'include':
                        # Include only specified folders: use OR with eq
                        conditions = [f"displayName eq '{escape_odata_string(name)}'" for name in folder_names]
                        filter = ' or '.join(conditions)
                    else:
                        # Exclude specified folders: use AND with ne
                        conditions = [f"displayName ne '{escape_odata_string(name)}'" for name in folder_names]
                        filter = ' and '.join(conditions)

                # Use typed query parameters for MailFolders
                query_params = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetQueryParameters()

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

                # Create proper typed request configuration for MailFolders
                config = MailFoldersRequestBuilder.MailFoldersRequestBuilderGetRequestConfiguration()
                config.query_parameters = query_params

                # Add consistency level for search operations
                if search:
                    if not config.headers:
                        config.headers = {}
                    config.headers.add('ConsistencyLevel', 'eventual')

                if headers:
                    if not config.headers:
                        config.headers = {}
                    for key, value in headers.items():
                        config.headers.add(key, value)

                response = await self.client.users.by_user_id(user_id).mail_folders.get(request_configuration=config)
            return self._handle_mail_folders_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_delta(
        self,
        user_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/mailFolders/delta()
        Operation type: mail
        Args:
            user_id (str, required): Outlook user 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_delete_mail_folders(
        self,
        user_id: str,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property mailFolders for users.
        Outlook operation: DELETE /users/{user-id}/mailFolders/{mailFolder-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_get_mail_folders(
        self,
        user_id: str,
        mailFolder_id: str,
        includeHiddenFolders: Optional[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
    ) -> OutlookCalendarContactsResponse:
        """Get mailFolders from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            includeHiddenFolders (str, optional): Include Hidden Folders
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_update_mail_folders(
        self,
        user_id: str,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property mailFolders in users.
        Outlook operation: PATCH /users/{user-id}/mailFolders/{mailFolder-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_create_child_folders(
        self,
        user_id: str,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to childFolders for users.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_list_child_folders(
        self,
        user_id: str,
        mailFolder_id: str,
        includeHiddenFolders: Optional[str] = None,
        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
    ) -> OutlookCalendarContactsResponse:
        """Get childFolders from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/childFolders
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            includeHiddenFolders (str, optional): Include Hidden Folders
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_delta(
        self,
        user_id: str,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/delta()
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_delete_child_folders(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property childFolders for users.
        Outlook operation: DELETE /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_get_child_folders(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        includeHiddenFolders: Optional[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
    ) -> OutlookCalendarContactsResponse:
        """Get childFolders from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            includeHiddenFolders (str, optional): Include Hidden Folders
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_update_child_folders(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property childFolders in users.
        Outlook operation: PATCH /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_copy(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action copy.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/copy
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).copy.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_create_message_rules(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to messageRules for users.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messageRules
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).message_rules.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_list_message_rules(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Get messageRules from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messageRules
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).message_rules.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_delete_message_rules(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        messageRule_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property messageRules for users.
        Outlook operation: DELETE /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messageRules/{messageRule-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            messageRule_id (str, required): Outlook messageRule id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).message_rules.by_message_rule_id(messageRule_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_get_message_rules(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        messageRule_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
    ) -> OutlookCalendarContactsResponse:
        """Get messageRules from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messageRules/{messageRule-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            messageRule_id (str, required): Outlook messageRule 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).message_rules.by_message_rule_id(messageRule_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_update_message_rules(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        messageRule_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property messageRules in users.
        Outlook operation: PATCH /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messageRules/{messageRule-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            messageRule_id (str, required): Outlook messageRule id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).message_rules.by_message_rule_id(messageRule_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_create_messages(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to messages for users.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_list_messages(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Get messages from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_messages_delta(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        changeType: Optional[str] = None,
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/delta()
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            changeType (str, optional): A custom query option to filter the delta response based on the type of change. Supported values are created, updated or deleted.
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_delete_messages(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property messages for users.
        Outlook operation: DELETE /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_get_messages(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Get messages from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_update_messages(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property messages in users.
        Outlook operation: PATCH /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_delete_messages_content(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Delete media content for the navigation property messages in users.
        Outlook operation: DELETE /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/$value
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).value.delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_get_messages_content(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Get media content for the navigation property messages from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/$value
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).value.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_update_messages_content(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Update media content for the navigation property messages in users.
        Outlook operation: PUT /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/$value
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).value.put(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_messages_create_attachments(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for users.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/attachments
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_messages_list_attachments(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/attachments
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_messages_message_attachments_create_upload_session(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/attachments/createUploadSession
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_messages_delete_attachments(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for users.
        Outlook operation: DELETE /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/attachments/{attachment-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_child_folders_messages_get_attachments(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/attachments/{attachment-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_messages_message_copy(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action copy.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/copy
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).copy.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_messages_message_create_forward(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createForward.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/createForward
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).create_forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_messages_message_create_reply(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createReply.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/createReply
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).create_reply.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_messages_message_create_reply_all(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createReplyAll.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/createReplyAll
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).create_reply_all.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_messages_message_forward(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/forward
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_messages_message_move(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action move.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/move
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).move.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_messages_message_permanent_delete(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/permanentDelete
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_messages_message_reply(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action reply.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/reply
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).reply.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_messages_message_reply_all(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action replyAll.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/replyAll
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).reply_all.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_messages_message_send(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action send.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/send
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).messages.by_message_id(message_id).send.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_move(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action move.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/move
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).move.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_child_folders_mail_folder_permanent_delete(
        self,
        user_id: str,
        mailFolder_id: str,
        mailFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/permanentDelete
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            mailFolder_id1 (str, required): Outlook mailFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).child_folders.by_childFolder_id(mailFolder_id1).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_copy(
        self,
        user_id: str,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action copy.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/copy
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).copy.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_create_message_rules(
        self,
        user_id: str,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to messageRules for users.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/messageRules
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).message_rules.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_list_message_rules(
        self,
        user_id: str,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Get messageRules from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/messageRules
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).message_rules.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_delete_message_rules(
        self,
        user_id: str,
        mailFolder_id: str,
        messageRule_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property messageRules for users.
        Outlook operation: DELETE /users/{user-id}/mailFolders/{mailFolder-id}/messageRules/{messageRule-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            messageRule_id (str, required): Outlook messageRule id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).message_rules.by_message_rule_id(messageRule_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_get_message_rules(
        self,
        user_id: str,
        mailFolder_id: str,
        messageRule_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
    ) -> OutlookCalendarContactsResponse:
        """Get messageRules from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/messageRules/{messageRule-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            messageRule_id (str, required): Outlook messageRule 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).message_rules.by_message_rule_id(messageRule_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_update_message_rules(
        self,
        user_id: str,
        mailFolder_id: str,
        messageRule_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property messageRules in users.
        Outlook operation: PATCH /users/{user-id}/mailFolders/{mailFolder-id}/messageRules/{messageRule-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            messageRule_id (str, required): Outlook messageRule id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).message_rules.by_message_rule_id(messageRule_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_create_messages(
        self,
        user_id: str,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to messages for users.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/messages
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_list_messages(
        self,
        user_id: str,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Get messages from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/messages
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_messages_delta(
        self,
        user_id: str,
        mailFolder_id: str,
        continuation_url: Optional[str] = None,
        page_size: Optional[int] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        filter: Optional[str] = None,
        orderby: Optional[str] = None,
        search: Optional[str] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta with pagination support.

        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            continuation_url (str, optional): Complete nextLink or deltaLink URL from previous response
            page_size (int, optional): Preferred page size (max 200 for messages)
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments)
            filter (optional): Filter the results using OData syntax (limited support)
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages by content
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error including pagination links
        """
        # Build query parameters including OData for Outlook
        try:
            if continuation_url:
                # Use the complete URL from nextLink or deltaLink
                response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.delta.with_url(continuation_url).get()
            else:
                # Create query parameters object
                query_params = DeltaRequestBuilder.DeltaRequestBuilderGetQueryParameters()

                # Set query parameters
                if select:
                    query_params.select = select if isinstance(select, list) else [select]
                if expand:
                    query_params.expand = expand if isinstance(expand, list) else [expand]
                if filter:
                    query_params.filter = filter
                if orderby:
                    query_params.orderby = orderby
                if search:
                    query_params.search = search

                # Create request configuration with query parameters using typed class
                request_configuration = DeltaRequestBuilder.DeltaRequestBuilderGetRequestConfiguration(
                    query_parameters=query_params
                )

                # Build headers
                if page_size or search or headers:
                    if not request_configuration.headers:
                        request_configuration.headers = {}

                    if page_size:
                        request_configuration.headers.add("Prefer", f"odata.maxpagesize={page_size}")

                    if search:
                        request_configuration.headers.add("ConsistencyLevel", "eventual")

                    if headers:
                        for key, value in headers.items():
                            request_configuration.headers.add(key, value)

                response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.delta.get(request_configuration=request_configuration)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_delete_messages(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property messages for users.
        Outlook operation: DELETE /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_get_messages(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Get messages from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_update_messages(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property messages in users.
        Outlook operation: PATCH /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_delete_messages_content(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Delete media content for the navigation property messages in users.
        Outlook operation: DELETE /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/$value
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).value.delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_get_messages_content(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Get media content for the navigation property messages from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/$value
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).value.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_update_messages_content(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Update media content for the navigation property messages in users.
        Outlook operation: PUT /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/$value
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).value.put(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_messages_create_attachments(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for users.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/attachments
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_messages_list_attachments(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/attachments
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_messages_message_attachments_create_upload_session(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/attachments/createUploadSession
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_messages_delete_attachments(
        self,
        user_id: str,
        mailFolder_id: str,
        message_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for users.
        Outlook operation: DELETE /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/attachments/{attachment-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_mail_folders_messages_get_attachments(
        self,
        user_id: str,
        mailFolder_id: str,
        message_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from users.
        Outlook operation: GET /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/attachments/{attachment-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_messages_message_copy(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action copy.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/copy
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).copy.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_messages_message_create_forward(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createForward.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/createForward
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).create_forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_messages_message_create_reply(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createReply.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/createReply
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).create_reply.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_messages_message_create_reply_all(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createReplyAll.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/createReplyAll
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).create_reply_all.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_messages_message_forward(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/forward
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_messages_message_move(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action move.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/move
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).move.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_messages_message_permanent_delete(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/permanentDelete
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_messages_message_reply(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action reply.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/reply
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).reply.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_messages_message_reply_all(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action replyAll.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/replyAll
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).reply_all.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_messages_message_send(
        self,
        user_id: str,
        mailFolder_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action send.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/send
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).messages.by_message_id(message_id).send.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_move(
        self,
        user_id: str,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action move.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/move
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).move.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_mail_folders_mail_folder_permanent_delete(
        self,
        user_id: str,
        mailFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/mailFolders/{mailFolder-id}/permanentDelete
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            mailFolder_id (str, required): Outlook mailFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mail_folders.by_mail_folder_id(mailFolder_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_get_mailbox_settings(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get mailboxSettings property value.
        Outlook operation: GET /users/{user-id}/mailboxSettings
        Operation type: mail
        Args:
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mailbox_settings.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_update_mailbox_settings(
        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
    ) -> OutlookCalendarContactsResponse:
        """Update property mailboxSettings value..
        Outlook operation: PATCH /users/{user-id}/mailboxSettings
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).mailbox_settings.patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_create_messages(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to messages for users.
        Outlook operation: POST /users/{user-id}/messages
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_list_messages(
        self,
        user_id: str,
        includeHiddenMessages: Optional[str] = None,
        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
    ) -> OutlookCalendarContactsResponse:
        """Get messages from users.
        Outlook operation: GET /users/{user-id}/messages
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            includeHiddenMessages (str, optional): Include Hidden Messages
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).messages.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_messages_delta(
        self,
        user_id: str,
        changeType: Optional[str] = None,
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/messages/delta()
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            changeType (str, optional): A custom query option to filter the delta response based on the type of change. Supported values are created, updated or deleted.
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).messages.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_delete_messages(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property messages for users.
        Outlook operation: DELETE /users/{user-id}/messages/{message-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_get_messages(
        self,
        user_id: str,
        message_id: str,
        includeHiddenMessages: Optional[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
    ) -> OutlookCalendarContactsResponse:
        """Get messages from users.
        Outlook operation: GET /users/{user-id}/messages/{message-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            includeHiddenMessages (str, optional): Include Hidden Messages
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_update_messages(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property messages in users.
        Outlook operation: PATCH /users/{user-id}/messages/{message-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_delete_messages_content(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Delete media content for the navigation property messages in users.
        Outlook operation: DELETE /users/{user-id}/messages/{message-id}/$value
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).value.delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_get_messages_content(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Get media content for the navigation property messages from users.
        Outlook operation: GET /users/{user-id}/messages/{message-id}/$value
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).value.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_update_messages_content(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Update media content for the navigation property messages in users.
        Outlook operation: PUT /users/{user-id}/messages/{message-id}/$value
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).value.put(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_messages_create_attachments(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for users.
        Outlook operation: POST /users/{user-id}/messages/{message-id}/attachments
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_messages_list_attachments(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from users.
        Outlook operation: GET /users/{user-id}/messages/{message-id}/attachments
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_messages_message_attachments_create_upload_session(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /users/{user-id}/messages/{message-id}/attachments/createUploadSession
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_messages_delete_attachments(
        self,
        user_id: str,
        message_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for users.
        Outlook operation: DELETE /users/{user-id}/messages/{message-id}/attachments/{attachment-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_messages_get_attachments(
        self,
        user_id: str,
        message_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from users.
        Outlook operation: GET /users/{user-id}/messages/{message-id}/attachments/{attachment-id}
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_messages_message_copy(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action copy.
        Outlook operation: POST /users/{user-id}/messages/{message-id}/copy
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).copy.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_messages_message_create_forward(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createForward.
        Outlook operation: POST /users/{user-id}/messages/{message-id}/createForward
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).create_forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_messages_message_create_reply(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createReply.
        Outlook operation: POST /users/{user-id}/messages/{message-id}/createReply
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).create_reply.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_messages_message_create_reply_all(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createReplyAll.
        Outlook operation: POST /users/{user-id}/messages/{message-id}/createReplyAll
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).create_reply_all.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_messages_message_forward(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /users/{user-id}/messages/{message-id}/forward
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_messages_message_move(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action move.
        Outlook operation: POST /users/{user-id}/messages/{message-id}/move
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).move.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_messages_message_permanent_delete(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/messages/{message-id}/permanentDelete
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_messages_message_reply(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action reply.
        Outlook operation: POST /users/{user-id}/messages/{message-id}/reply
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).reply.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_messages_message_reply_all(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action replyAll.
        Outlook operation: POST /users/{user-id}/messages/{message-id}/replyAll
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).reply_all.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_messages_message_send(
        self,
        user_id: str,
        message_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action send.
        Outlook operation: POST /users/{user-id}/messages/{message-id}/send
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            message_id (str, required): Outlook message id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).messages.by_message_id(message_id).send.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_presence_set_status_message(
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action setStatusMessage.
        Outlook operation: POST /users/{user-id}/presence/setStatusMessage
        Operation type: mail
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).presence.set_status_message.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    # ========== CALENDAR OPERATIONS (327 methods) ==========

    async def groups_get_calendar(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get calendar from groups.
        Outlook operation: GET /groups/{group-id}/calendar
        Operation type: calendar
        Args:
            group_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

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

    async def groups_group_calendar_allowed_calendar_sharing_roles(
        self,
        group_id: str,
        User: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function allowedCalendarSharingRoles.
        Outlook operation: GET /groups/{group-id}/calendar/allowedCalendarSharingRoles(User='{User}')
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            User (str, required): User identifier: User
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.allowed_calendar_sharing_roles(_user='{_user}').get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_create_calendar_permissions(
        self,
        group_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to calendarPermissions for groups.
        Outlook operation: POST /groups/{group-id}/calendar/calendarPermissions
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.calendar_permissions.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_list_calendar_permissions(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarPermissions from groups.
        Outlook operation: GET /groups/{group-id}/calendar/calendarPermissions
        Operation type: calendar
        Args:
            group_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.calendar_permissions.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_delete_calendar_permissions(
        self,
        group_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property calendarPermissions for groups.
        Outlook operation: DELETE /groups/{group-id}/calendar/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            calendarPermission_id (str, required): Outlook calendarPermission id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.calendar_permissions.by_calendarPermission_id(calendarPermission_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_get_calendar_permissions(
        self,
        group_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarPermissions from groups.
        Outlook operation: GET /groups/{group-id}/calendar/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            calendarPermission_id (str, required): Outlook calendarPermission 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.calendar_permissions.by_calendarPermission_id(calendarPermission_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_update_calendar_permissions(
        self,
        group_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property calendarPermissions in groups.
        Outlook operation: PATCH /groups/{group-id}/calendar/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            calendarPermission_id (str, required): Outlook calendarPermission id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.calendar_permissions.by_calendarPermission_id(calendarPermission_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_list_calendar_view(
        self,
        group_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarView from groups.
        Outlook operation: GET /groups/{group-id}/calendar/calendarView
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.calendar_view.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_calendar_calendar_view_delta(
        self,
        group_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /groups/{group-id}/calendar/calendarView/delta()
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.calendar_view.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_create_events(
        self,
        group_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to events for groups.
        Outlook operation: POST /groups/{group-id}/calendar/events
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_list_events(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get events from groups.
        Outlook operation: GET /groups/{group-id}/calendar/events
        Operation type: calendar
        Args:
            group_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_calendar_events_delta(
        self,
        group_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /groups/{group-id}/calendar/events/delta()
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_delete_events(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property events for groups.
        Outlook operation: DELETE /groups/{group-id}/calendar/events/{event-id}
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_get_events(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get events from groups.
        Outlook operation: GET /groups/{group-id}/calendar/events/{event-id}
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_update_events(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Update event.
        Outlook operation: PATCH /groups/{group-id}/calendar/events/{event-id}
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_calendar_events_event_accept(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action accept.
        Outlook operation: POST /groups/{group-id}/calendar/events/{event-id}/accept
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_events_create_attachments(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for groups.
        Outlook operation: POST /groups/{group-id}/calendar/events/{event-id}/attachments
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_events_list_attachments(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from groups.
        Outlook operation: GET /groups/{group-id}/calendar/events/{event-id}/attachments
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_calendar_events_event_attachments_create_upload_session(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /groups/{group-id}/calendar/events/{event-id}/attachments/createUploadSession
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_events_delete_attachments(
        self,
        group_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for groups.
        Outlook operation: DELETE /groups/{group-id}/calendar/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_events_get_attachments(
        self,
        group_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from groups.
        Outlook operation: GET /groups/{group-id}/calendar/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_events_get_calendar(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendar from groups.
        Outlook operation: GET /groups/{group-id}/calendar/events/{event-id}/calendar
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).calendar.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_calendar_events_event_cancel(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action cancel.
        Outlook operation: POST /groups/{group-id}/calendar/events/{event-id}/cancel
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).cancel.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_calendar_events_event_decline(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action decline.
        Outlook operation: POST /groups/{group-id}/calendar/events/{event-id}/decline
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).decline.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_calendar_events_event_dismiss_reminder(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action dismissReminder.
        Outlook operation: POST /groups/{group-id}/calendar/events/{event-id}/dismissReminder
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).dismiss_reminder.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_calendar_events_event_forward(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /groups/{group-id}/calendar/events/{event-id}/forward
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_calendar_events_list_instances(
        self,
        group_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get instances from groups.
        Outlook operation: GET /groups/{group-id}/calendar/events/{event-id}/instances
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).instances.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_calendar_events_event_instances_delta(
        self,
        group_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /groups/{group-id}/calendar/events/{event-id}/instances/delta()
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).instances.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_calendar_events_event_permanent_delete(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /groups/{group-id}/calendar/events/{event-id}/permanentDelete
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_calendar_events_event_snooze_reminder(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action snoozeReminder.
        Outlook operation: POST /groups/{group-id}/calendar/events/{event-id}/snoozeReminder
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).snooze_reminder.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_calendar_events_event_tentatively_accept(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action tentativelyAccept.
        Outlook operation: POST /groups/{group-id}/calendar/events/{event-id}/tentativelyAccept
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.events.by_event_id(event_id).tentatively_accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_calendar_get_schedule(
        self,
        group_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action getSchedule.
        Outlook operation: POST /groups/{group-id}/calendar/getSchedule
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.get_schedule.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_calendar_permanent_delete(
        self,
        group_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /groups/{group-id}/calendar/permanentDelete
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar.permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_list_calendar_view(
        self,
        group_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """List group calendarView.
        Outlook operation: GET /groups/{group-id}/calendarView
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

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

    async def groups_group_calendar_view_delta(
        self,
        group_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /groups/{group-id}/calendarView/delta()
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).calendar_view.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_create_events(
        self,
        group_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
    ) -> OutlookCalendarContactsResponse:
        """Create event.
        Outlook operation: POST /groups/{group-id}/events
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_list_events(
        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
    ) -> OutlookCalendarContactsResponse:
        """List events.
        Outlook operation: GET /groups/{group-id}/events
        Operation type: calendar
        Args:
            group_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

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

    async def groups_group_events_delta(
        self,
        group_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /groups/{group-id}/events/delta()
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_delete_events(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Delete event.
        Outlook operation: DELETE /groups/{group-id}/events/{event-id}
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_get_events(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get event.
        Outlook operation: GET /groups/{group-id}/events/{event-id}
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_update_events(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property events in groups.
        Outlook operation: PATCH /groups/{group-id}/events/{event-id}
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_events_event_accept(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action accept.
        Outlook operation: POST /groups/{group-id}/events/{event-id}/accept
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_events_create_attachments(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for groups.
        Outlook operation: POST /groups/{group-id}/events/{event-id}/attachments
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_events_list_attachments(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from groups.
        Outlook operation: GET /groups/{group-id}/events/{event-id}/attachments
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_events_event_attachments_create_upload_session(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /groups/{group-id}/events/{event-id}/attachments/createUploadSession
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_events_delete_attachments(
        self,
        group_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for groups.
        Outlook operation: DELETE /groups/{group-id}/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_events_get_attachments(
        self,
        group_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from groups.
        Outlook operation: GET /groups/{group-id}/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_events_get_calendar(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendar from groups.
        Outlook operation: GET /groups/{group-id}/events/{event-id}/calendar
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).calendar.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_events_event_cancel(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action cancel.
        Outlook operation: POST /groups/{group-id}/events/{event-id}/cancel
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).cancel.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_events_event_decline(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action decline.
        Outlook operation: POST /groups/{group-id}/events/{event-id}/decline
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).decline.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_events_event_dismiss_reminder(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action dismissReminder.
        Outlook operation: POST /groups/{group-id}/events/{event-id}/dismissReminder
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).dismiss_reminder.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_events_event_forward(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /groups/{group-id}/events/{event-id}/forward
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_events_list_instances(
        self,
        group_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get instances from groups.
        Outlook operation: GET /groups/{group-id}/events/{event-id}/instances
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).instances.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_events_event_instances_delta(
        self,
        group_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /groups/{group-id}/events/{event-id}/instances/delta()
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).instances.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_events_event_permanent_delete(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /groups/{group-id}/events/{event-id}/permanentDelete
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_events_event_snooze_reminder(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action snoozeReminder.
        Outlook operation: POST /groups/{group-id}/events/{event-id}/snoozeReminder
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).snooze_reminder.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_events_event_tentatively_accept(
        self,
        group_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action tentativelyAccept.
        Outlook operation: POST /groups/{group-id}/events/{event-id}/tentativelyAccept
        Operation type: calendar
        Args:
            group_id (str, required): Outlook group id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).events.by_event_id(event_id).tentatively_accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_get_calendar(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get calendar.
        Outlook operation: GET /me/calendar
        Operation type: calendar
        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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_update_calendar(
        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
    ) -> OutlookCalendarContactsResponse:
        """Update calendar.
        Outlook operation: PATCH /me/calendar
        Operation type: calendar
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_allowed_calendar_sharing_roles(
        self,
        User: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function allowedCalendarSharingRoles.
        Outlook operation: GET /me/calendar/allowedCalendarSharingRoles(User='{User}')
        Operation type: calendar
        Args:
            User (str, required): User identifier: User
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.allowed_calendar_sharing_roles(_user='{_user}').get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_list_calendar_permissions(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarPermissions from me.
        Outlook operation: GET /me/calendar/calendarPermissions
        Operation type: calendar
        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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.calendar_permissions.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_delete_calendar_permissions(
        self,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property calendarPermissions for me.
        Outlook operation: DELETE /me/calendar/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            calendarPermission_id (str, required): Outlook calendarPermission id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.calendar_permissions.by_calendarPermission_id(calendarPermission_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_get_calendar_permissions(
        self,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarPermissions from me.
        Outlook operation: GET /me/calendar/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            calendarPermission_id (str, required): Outlook calendarPermission 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.calendar_permissions.by_calendarPermission_id(calendarPermission_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_update_calendar_permissions(
        self,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property calendarPermissions in me.
        Outlook operation: PATCH /me/calendar/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            calendarPermission_id (str, required): Outlook calendarPermission id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.calendar_permissions.by_calendarPermission_id(calendarPermission_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_calendar_view_delta(
        self,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/calendar/calendarView/delta()
        Operation type: calendar
        Args:
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.calendar_view.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )


    async def me_calendar_create_events(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create a calendar event.
        Outlook operation: POST /me/calendar/events
        """
        try:
            config = RequestConfiguration()
            if headers:
                config.headers = headers

            # Convert dict to typed Event object (SDK requires .serialize())
            body = request_body
            if isinstance(request_body, dict):
                body = _dict_to_event(request_body)

            response = await self.client.me.calendar.events.post(body=body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_list_events(
        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
    ) -> OutlookCalendarContactsResponse:
        """List events.
        Outlook operation: GET /me/calendar/events
        Operation type: calendar
        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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_delta(
        self,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/calendar/events/delta()
        Operation type: calendar
        Args:
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_delete_events(
        self,
        event_id: str,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        """Delete a calendar event.
        Outlook operation: DELETE /me/calendar/events/{event-id}
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            headers (optional): Additional headers for the request
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper
        """
        try:
            config = RequestConfiguration()
            if headers:
                config.headers = headers

            response = await self.client.me.calendar.events.by_event_id(event_id).delete(
                request_configuration=config
            )
            # DELETE returns 204 No Content — None means success
            if response is None:
                return OutlookCalendarContactsResponse(
                    success=True,
                    data={"event_id": event_id, "status": "deleted"},
                )
            return self._handle_outlook_response(response)
        except Exception as e:
            error_msg = str(e)
            error_type = type(e).__name__
            logger.error(f"Error in me_calendar_delete_events ({error_type}): {error_msg}")
            if "404" in error_msg or "not found" in error_msg.lower():
                return OutlookCalendarContactsResponse(
                    success=False,
                    error=f"Calendar event not found (404). The event ID '{event_id}' may be invalid or the event may have been deleted.",
                )
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {error_msg}",
            )

    async def me_calendar_get_events(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get events from me.
        Outlook operation: GET /me/calendar/events/{event-id}
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_update_events(
        self,
        event_id: str,
        request_body: Optional[Mapping[str, Any]] = None,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        headers: Optional[Dict[str, str]] = None,
        update_scope: str = "allEvents",
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        import copy

        try:
            # Create a mutable deep copy to safely manipulate payload dates
            body_dict = copy.deepcopy(dict(request_body)) if isinstance(request_body, dict) else request_body

            original_start_date = None
            original_end_date = None
            is_series_master = False
            existing_recurrence = None  # <-- NEW

            try:
                event = await self.client.me.calendar.events.by_event_id(event_id).get()
                if event is not None:
                    event_type = getattr(event, 'type', None)
                    event_type_str = event_type.value if hasattr(event_type, 'value') else str(event_type)

                    # 1. Redirect occurrences to series master
                    if "occurrence" in event_type_str.lower() or "exception" in event_type_str.lower():
                        series_master_id = getattr(event, 'series_master_id', None)
                        if series_master_id:
                            logger.info(f"Redirecting update from occurrence {event_id} to series master {series_master_id}")
                            event_id = series_master_id
                            # Re-fetch the series master to get its true data
                            event = await self.client.me.calendar.events.by_event_id(event_id).get()
                            event_type = getattr(event, 'type', None)
                            event_type_str = event_type.value if hasattr(event_type, 'value') else str(event_type)
                        else:
                            return OutlookCalendarContactsResponse(
                                success=False,
                                error="Cannot update recurrence on an occurrence instance. Series master ID not found.",
                            )

                    # 2. Extract Master Dates
                    if "seriesmaster" in event_type_str.lower():
                        is_series_master = True
                        existing_recurrence = getattr(event, 'recurrence', None)  # <-- NEW

                    start_obj = getattr(event, 'start', None)
                    if start_obj and getattr(start_obj, 'date_time', None):
                        original_start_date = start_obj.date_time[:10]  # e.g. "2026-01-01"

                    end_obj = getattr(event, 'end', None)
                    if end_obj and getattr(end_obj, 'date_time', None):
                        original_end_date = end_obj.date_time[:10]

            except Exception as lookup_err:
                logger.warning(f"Could not verify event type before update: {lookup_err}")

            # 3. Fix Payload Dates (CRITICAL for recurring events)
            if isinstance(body_dict, dict) and is_series_master:
                # Fix recurrence range startDate
                if "recurrence" in body_dict and isinstance(body_dict["recurrence"], dict):
                    rec = body_dict["recurrence"]
                    if "range" in rec and original_start_date:
                        rec["range"]["startDate"] = original_start_date
                        logger.debug(f"Forced recurrence.range.startDate={original_start_date}")

                # Fix start time: Keep user's time, but force date back to Master's start date
                if "start" in body_dict and "dateTime" in body_dict["start"] and original_start_date:
                    req_start = body_dict["start"]["dateTime"]
                    if "T" in req_start:
                        req_time = req_start.split("T")[1]
                        body_dict["start"]["dateTime"] = f"{original_start_date}T{req_time}"
                        logger.debug(f"Forced start.dateTime={body_dict['start']['dateTime']}")

                # Fix end time: Keep user's time, but force date back to Master's end date
                if "end" in body_dict and "dateTime" in body_dict["end"] and original_end_date:
                    req_end = body_dict["end"]["dateTime"]
                    if "T" in req_end:
                        req_time = req_end.split("T")[1]
                        body_dict["end"]["dateTime"] = f"{original_end_date}T{req_time}"
                        logger.debug(f"Forced end.dateTime={body_dict['end']['dateTime']}")

                # 4. NEW: Preserve existing recurrence if caller didn't supply one
                # Without this, Graph API strips recurrence from the series master
                # and may create a new standalone event instead of updating the series.
                if "recurrence" not in body_dict and existing_recurrence is not None:
                    try:
                        rec_pattern = getattr(existing_recurrence, 'pattern', None)
                        rec_range = getattr(existing_recurrence, 'range', None)

                        if rec_pattern and rec_range:
                            # Safely extract enum values
                            def _enum_val(obj, attr):
                                v = getattr(obj, attr, None)
                                if v is None:
                                    return None
                                return v.value if hasattr(v, 'value') else str(v)

                            days_of_week = getattr(rec_pattern, 'days_of_week', None) or []
                            days_of_week_vals = [
                                d.value if hasattr(d, 'value') else str(d)
                                for d in days_of_week
                            ]

                            body_dict["recurrence"] = {
                                "pattern": {
                                    "type": _enum_val(rec_pattern, 'type'),
                                    "interval": getattr(rec_pattern, 'interval', 1),
                                    "firstDayOfWeek": _enum_val(rec_pattern, 'first_day_of_week'),
                                    "dayOfMonth": getattr(rec_pattern, 'day_of_month', 0),
                                    "month": getattr(rec_pattern, 'month', 0),
                                    "index": _enum_val(rec_pattern, 'index'),
                                    "daysOfWeek": days_of_week_vals,
                                },
                                "range": {
                                    "type": _enum_val(rec_range, 'type'),
                                    "startDate": original_start_date or getattr(rec_range, 'start_date', None),
                                    "endDate": getattr(rec_range, 'end_date', None),
                                    "numberOfOccurrences": getattr(rec_range, 'number_of_occurrences', 0),
                                    "recurrenceTimeZone": getattr(rec_range, 'recurrence_time_zone', None),
                                }
                            }

                            # Strip None values from pattern and range to keep payload clean
                            body_dict["recurrence"]["pattern"] = {
                                k: v for k, v in body_dict["recurrence"]["pattern"].items()
                                if v is not None
                            }
                            body_dict["recurrence"]["range"] = {
                                k: v for k, v in body_dict["recurrence"]["range"].items()
                                if v is not None
                            }

                            logger.info(
                                f"Preserved existing recurrence on series master PATCH: "
                                f"{body_dict['recurrence']}"
                            )

                    except Exception as rec_err:
                        logger.warning(f"Could not preserve recurrence data: {rec_err}")

            config = RequestConfiguration()
            config.headers.try_add("Prefer", "outlook.allow-unsafe-updates")
            if headers:
                for key, value in headers.items():
                    config.headers.try_add(key, value)

            # Map the corrected dictionary back to the expected API object
            final_body = _dict_to_event(body_dict) if isinstance(body_dict, dict) else body_dict

            response = await self.client.me.calendar.events.by_event_id(event_id).patch(
                body=final_body, request_configuration=config
            )
            return self._handle_outlook_response(response)

        except Exception as e:
            error_msg = str(e)
            error_type = type(e).__name__
            logger.error(f"Error in me_calendar_update_events ({error_type}): {error_msg}")
            if "404" in error_msg or "not found" in error_msg.lower():
                return OutlookCalendarContactsResponse(
                    success=False,
                    error=f"Calendar event not found (404). The event ID '{event_id}' may be invalid.",
                )
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {error_msg}",
            )

    async def me_calendar_events_event_accept(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action accept.
        Outlook operation: POST /me/calendar/events/{event-id}/accept
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_create_attachments(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for me.
        Outlook operation: POST /me/calendar/events/{event-id}/attachments
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_list_attachments(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from me.
        Outlook operation: GET /me/calendar/events/{event-id}/attachments
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_event_attachments_create_upload_session(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /me/calendar/events/{event-id}/attachments/createUploadSession
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_delete_attachments(
        self,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for me.
        Outlook operation: DELETE /me/calendar/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_get_attachments(
        self,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from me.
        Outlook operation: GET /me/calendar/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_get_calendar(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendar from me.
        Outlook operation: GET /me/calendar/events/{event-id}/calendar
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).calendar.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_event_cancel(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action cancel.
        Outlook operation: POST /me/calendar/events/{event-id}/cancel
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).cancel.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_event_decline(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action decline.
        Outlook operation: POST /me/calendar/events/{event-id}/decline
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).decline.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_event_dismiss_reminder(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action dismissReminder.
        Outlook operation: POST /me/calendar/events/{event-id}/dismissReminder
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).dismiss_reminder.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_event_forward(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /me/calendar/events/{event-id}/forward
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_list_instances(
        self,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get instances from me.
        Outlook operation: GET /me/calendar/events/{event-id}/instances
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).instances.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_event_instances_delta(
        self,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/calendar/events/{event-id}/instances/delta()
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).instances.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_event_permanent_delete(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/calendar/events/{event-id}/permanentDelete
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_event_snooze_reminder(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action snoozeReminder.
        Outlook operation: POST /me/calendar/events/{event-id}/snoozeReminder
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).snooze_reminder.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_events_event_tentatively_accept(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action tentativelyAccept.
        Outlook operation: POST /me/calendar/events/{event-id}/tentativelyAccept
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.events.by_event_id(event_id).tentatively_accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_get_schedule(
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action getSchedule.
        Outlook operation: POST /me/calendar/getSchedule
        Operation type: calendar
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.get_schedule.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_permanent_delete(
        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,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/calendar/permanentDelete
        Operation type: calendar
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_create_calendar_groups(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create CalendarGroup.
        Outlook operation: POST /me/calendarGroups
        Operation type: calendar
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_list_calendar_groups(
        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
    ) -> OutlookCalendarContactsResponse:
        """List calendarGroups.
        Outlook operation: GET /me/calendarGroups
        Operation type: calendar
        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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_delete_calendar_groups(
        self,
        calendarGroup_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
    ) -> OutlookCalendarContactsResponse:
        """Delete calendarGroup.
        Outlook operation: DELETE /me/calendarGroups/{calendarGroup-id}
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_get_calendar_groups(
        self,
        calendarGroup_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarGroup.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_update_calendar_groups(
        self,
        calendarGroup_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
    ) -> OutlookCalendarContactsResponse:
        """Update calendargroup.
        Outlook operation: PATCH /me/calendarGroups/{calendarGroup-id}
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_create_calendars(
        self,
        calendarGroup_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
    ) -> OutlookCalendarContactsResponse:
        """Create Calendar.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_list_calendars(
        self,
        calendarGroup_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
    ) -> OutlookCalendarContactsResponse:
        """List calendars.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_delete_calendars(
        self,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property calendars for me.
        Outlook operation: DELETE /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_get_calendars(
        self,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendars from me.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_update_calendars(
        self,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property calendars in me.
        Outlook operation: PATCH /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_allowed_calendar_sharing_roles(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        User: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function allowedCalendarSharingRoles.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/allowedCalendarSharingRoles(User='{User}')
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            User (str, required): User identifier: User
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).allowed_calendar_sharing_roles(_user='{_user}').get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_create_calendar_permissions(
        self,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to calendarPermissions for me.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/calendarPermissions
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).calendar_permissions.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_list_calendar_permissions(
        self,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarPermissions from me.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/calendarPermissions
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).calendar_permissions.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_delete_calendar_permissions(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property calendarPermissions for me.
        Outlook operation: DELETE /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            calendarPermission_id (str, required): Outlook calendarPermission id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).calendar_permissions.by_calendarPermission_id(calendarPermission_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_get_calendar_permissions(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarPermissions from me.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            calendarPermission_id (str, required): Outlook calendarPermission 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).calendar_permissions.by_calendarPermission_id(calendarPermission_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_update_calendar_permissions(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property calendarPermissions in me.
        Outlook operation: PATCH /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            calendarPermission_id (str, required): Outlook calendarPermission id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).calendar_permissions.by_calendarPermission_id(calendarPermission_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_list_calendar_view(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarView from me.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/calendarView
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).calendar_view.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_calendar_view_delta(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/calendarView/delta()
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).calendar_view.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_create_events(
        self,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to events for me.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_list_events(
        self,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Get events from me.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_events_delta(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/delta()
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_delete_events(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property events for me.
        Outlook operation: DELETE /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_get_events(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get events from me.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_update_events(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property events in me.
        Outlook operation: PATCH /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_events_event_accept(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action accept.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/accept
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_events_create_attachments(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for me.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/attachments
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_events_list_attachments(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from me.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/attachments
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_events_event_attachments_create_upload_session(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/attachments/createUploadSession
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_events_delete_attachments(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for me.
        Outlook operation: DELETE /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_events_get_attachments(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from me.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_events_get_calendar(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendar from me.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/calendar
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).calendar.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_events_event_cancel(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action cancel.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/cancel
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).cancel.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_events_event_decline(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action decline.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/decline
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).decline.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_events_event_dismiss_reminder(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action dismissReminder.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/dismissReminder
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).dismiss_reminder.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_events_event_forward(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/forward
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendars_events_list_instances(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get instances from me.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/instances
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).instances.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_events_event_instances_delta(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/instances/delta()
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).instances.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_events_event_permanent_delete(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/permanentDelete
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_events_event_snooze_reminder(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action snoozeReminder.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/snoozeReminder
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).snooze_reminder.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_events_event_tentatively_accept(
        self,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action tentativelyAccept.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/tentativelyAccept
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).tentatively_accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_get_schedule(
        self,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action getSchedule.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/getSchedule
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).get_schedule.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_groups_calendar_group_calendars_calendar_permanent_delete(
        self,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/permanentDelete
        Operation type: calendar
        Args:
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendar_list_calendar_view(
        self,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """List calendarView.
        Outlook operation: GET /me/calendar/calendarView
        """
        try:
            # CRITICAL: Use CalendarViewRequestBuilder's typed query params.
            # Generic RequestConfiguration() has NO date fields — setattr is
            # silently ignored by the SDK serializer.
            query_params = CalendarViewRequestBuilder.CalendarViewRequestBuilderGetQueryParameters(
                start_date_time=startDateTime,
                end_date_time=endDateTime,
            )

            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if expand:
                query_params.expand = expand if isinstance(expand, list) else [expand]
            if filter:
                query_params.filter = filter
            if orderby:
                query_params.orderby = [orderby] if isinstance(orderby, str) else orderby
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            config = CalendarViewRequestBuilder.CalendarViewRequestBuilderGetRequestConfiguration(
                query_parameters=query_params,
            )

            if headers:
                config.headers = headers

            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar.calendar_view.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )


    async def me_calendar_view_delta(
        self,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/calendarView/delta()
        Operation type: calendar
        Args:
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendar_view.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_create_calendars(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create calendar.
        Outlook operation: POST /me/calendars
        Operation type: calendar
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_list_calendars(
        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
    ) -> OutlookCalendarContactsResponse:
        """List calendars.
        Outlook operation: GET /me/calendars
        Operation type: calendar
        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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_delete_calendars(
        self,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property calendars for me.
        Outlook operation: DELETE /me/calendars/{calendar-id}
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_get_calendars(
        self,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendars from me.
        Outlook operation: GET /me/calendars/{calendar-id}
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.by_calendar_id(calendar_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_update_calendars(
        self,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property calendars in me.
        Outlook operation: PATCH /me/calendars/{calendar-id}
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_allowed_calendar_sharing_roles(
        self,
        calendar_id: str,
        User: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function allowedCalendarSharingRoles.
        Outlook operation: GET /me/calendars/{calendar-id}/allowedCalendarSharingRoles(User='{User}')
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            User (str, required): User identifier: User
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.by_calendar_id(calendar_id).allowed_calendar_sharing_roles(_user='{_user}').get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_create_calendar_permissions(
        self,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to calendarPermissions for me.
        Outlook operation: POST /me/calendars/{calendar-id}/calendarPermissions
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).calendar_permissions.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_list_calendar_permissions(
        self,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarPermissions from me.
        Outlook operation: GET /me/calendars/{calendar-id}/calendarPermissions
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.by_calendar_id(calendar_id).calendar_permissions.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_delete_calendar_permissions(
        self,
        calendar_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property calendarPermissions for me.
        Outlook operation: DELETE /me/calendars/{calendar-id}/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            calendarPermission_id (str, required): Outlook calendarPermission id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).calendar_permissions.by_calendarPermission_id(calendarPermission_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_get_calendar_permissions(
        self,
        calendar_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarPermissions from me.
        Outlook operation: GET /me/calendars/{calendar-id}/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            calendarPermission_id (str, required): Outlook calendarPermission 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.by_calendar_id(calendar_id).calendar_permissions.by_calendarPermission_id(calendarPermission_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_update_calendar_permissions(
        self,
        calendar_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property calendarPermissions in me.
        Outlook operation: PATCH /me/calendars/{calendar-id}/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            calendarPermission_id (str, required): Outlook calendarPermission id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).calendar_permissions.by_calendarPermission_id(calendarPermission_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_list_calendar_view(
        self,
        calendar_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarView from me.
        Outlook operation: GET /me/calendars/{calendar-id}/calendarView
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.by_calendar_id(calendar_id).calendar_view.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_calendar_view_delta(
        self,
        calendar_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/calendars/{calendar-id}/calendarView/delta()
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.by_calendar_id(calendar_id).calendar_view.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_create_events(
        self,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Create event.
        Outlook operation: POST /me/calendars/{calendar-id}/events
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_list_events(
        self,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Get events from me.
        Outlook operation: GET /me/calendars/{calendar-id}/events
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_events_delta(
        self,
        calendar_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/calendars/{calendar-id}/events/delta()
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_delete_events(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property events for me.
        Outlook operation: DELETE /me/calendars/{calendar-id}/events/{event-id}
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_get_events(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get events from me.
        Outlook operation: GET /me/calendars/{calendar-id}/events/{event-id}
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_update_events(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property events in me.
        Outlook operation: PATCH /me/calendars/{calendar-id}/events/{event-id}
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_events_event_accept(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action accept.
        Outlook operation: POST /me/calendars/{calendar-id}/events/{event-id}/accept
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_events_create_attachments(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for me.
        Outlook operation: POST /me/calendars/{calendar-id}/events/{event-id}/attachments
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_events_list_attachments(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from me.
        Outlook operation: GET /me/calendars/{calendar-id}/events/{event-id}/attachments
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_events_event_attachments_create_upload_session(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /me/calendars/{calendar-id}/events/{event-id}/attachments/createUploadSession
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_events_delete_attachments(
        self,
        calendar_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for me.
        Outlook operation: DELETE /me/calendars/{calendar-id}/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_events_get_attachments(
        self,
        calendar_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from me.
        Outlook operation: GET /me/calendars/{calendar-id}/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_events_get_calendar(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendar from me.
        Outlook operation: GET /me/calendars/{calendar-id}/events/{event-id}/calendar
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).calendar.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_events_event_cancel(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action cancel.
        Outlook operation: POST /me/calendars/{calendar-id}/events/{event-id}/cancel
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).cancel.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_events_event_decline(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action decline.
        Outlook operation: POST /me/calendars/{calendar-id}/events/{event-id}/decline
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).decline.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_events_event_dismiss_reminder(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action dismissReminder.
        Outlook operation: POST /me/calendars/{calendar-id}/events/{event-id}/dismissReminder
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).dismiss_reminder.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_events_event_forward(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /me/calendars/{calendar-id}/events/{event-id}/forward
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_events_list_instances(
        self,
        calendar_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get instances from me.
        Outlook operation: GET /me/calendars/{calendar-id}/events/{event-id}/instances
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).instances.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_events_event_instances_delta(
        self,
        calendar_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/calendars/{calendar-id}/events/{event-id}/instances/delta()
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = CalendarsRequestBuilder.CalendarsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).instances.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_events_event_permanent_delete(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/calendars/{calendar-id}/events/{event-id}/permanentDelete
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_events_event_snooze_reminder(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action snoozeReminder.
        Outlook operation: POST /me/calendars/{calendar-id}/events/{event-id}/snoozeReminder
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).snooze_reminder.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_events_event_tentatively_accept(
        self,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action tentativelyAccept.
        Outlook operation: POST /me/calendars/{calendar-id}/events/{event-id}/tentativelyAccept
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).tentatively_accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_get_schedule(
        self,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action getSchedule.
        Outlook operation: POST /me/calendars/{calendar-id}/getSchedule
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).get_schedule.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_calendars_calendar_permanent_delete(
        self,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/calendars/{calendar-id}/permanentDelete
        Operation type: calendar
        Args:
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.calendars.by_calendar_id(calendar_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_list_events(
        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
    ) -> OutlookCalendarContactsResponse:
        """List events.
        Outlook operation: GET /me/events
        Operation type: calendar
        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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.events.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )
    async def me_search_events(
        self,
        search: str,
        select: Optional[List[str]] = None,
        top: Optional[int] = None,
        timezone: str = "India Standard Time",
    ) -> OutlookCalendarContactsResponse:
        """
        Stable keyword search using subject only.
        """

        try:
            if not search or not search.strip():
                raise ValueError("Search cannot be empty.")

            keyword = search.strip().replace("'", "''")

            # SAFE filter — subject only
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters(
                filter=f"contains(subject,'{keyword}')"
            )

            if select:
                query_params.select = select

            if top is not None:
                query_params.top = top

            config = EventsRequestBuilder.EventsRequestBuilderGetRequestConfiguration(
                query_parameters=query_params
            )
            config.headers.try_add("Prefer", f'outlook.timezone="{timezone}"')  # <-- ADD THIS

            response = await self.client.me.events.get(
                request_configuration=config
            )

            return self._handle_outlook_response(response)

        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Event search failed: {str(e)}",
            )

    async def me_events_delta(
        self,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/events/delta()
        Operation type: calendar
        Args:
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.events.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_delete_events(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Delete event.
        Outlook operation: DELETE /me/events/{event-id}
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.events.by_event_id(event_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_update_events(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Update event.
        Outlook operation: PATCH /me/events/{event-id}
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.events.by_event_id(event_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_event_accept(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action accept.
        Outlook operation: POST /me/events/{event-id}/accept
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.events.by_event_id(event_id).accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_create_attachments(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Add attachment.
        Outlook operation: POST /me/events/{event-id}/attachments
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.events.by_event_id(event_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_list_attachments(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """List attachments.
        Outlook operation: GET /me/events/{event-id}/attachments
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.events.by_event_id(event_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_event_attachments_create_upload_session(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /me/events/{event-id}/attachments/createUploadSession
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.events.by_event_id(event_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_delete_attachments(
        self,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete attachment.
        Outlook operation: DELETE /me/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_get_attachments(
        self,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from me.
        Outlook operation: GET /me/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_get_calendar(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendar from me.
        Outlook operation: GET /me/events/{event-id}/calendar
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.events.by_event_id(event_id).calendar.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_event_cancel(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action cancel.
        Outlook operation: POST /me/events/{event-id}/cancel
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.events.by_event_id(event_id).cancel.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_event_decline(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action decline.
        Outlook operation: POST /me/events/{event-id}/decline
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.events.by_event_id(event_id).decline.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_event_dismiss_reminder(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action dismissReminder.
        Outlook operation: POST /me/events/{event-id}/dismissReminder
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.events.by_event_id(event_id).dismiss_reminder.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_event_forward(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /me/events/{event-id}/forward
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.events.by_event_id(event_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_list_instances(
        self,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """List instances.
        Outlook operation: GET /me/events/{event-id}/instances
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.events.by_event_id(event_id).instances.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_event_instances_delta(
        self,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/events/{event-id}/instances/delta()
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.events.by_event_id(event_id).instances.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_event_permanent_delete(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/events/{event-id}/permanentDelete
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.events.by_event_id(event_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_event_snooze_reminder(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action snoozeReminder.
        Outlook operation: POST /me/events/{event-id}/snoozeReminder
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.events.by_event_id(event_id).snooze_reminder.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_events_event_tentatively_accept(
        self,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action tentativelyAccept.
        Outlook operation: POST /me/events/{event-id}/tentativelyAccept
        Operation type: calendar
        Args:
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.events.by_event_id(event_id).tentatively_accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_get_calendar(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get calendar from users.
        Outlook operation: GET /users/{user-id}/calendar
        Operation type: calendar
        Args:
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_update_calendar(
        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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property calendar in users.
        Outlook operation: PATCH /users/{user-id}/calendar
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_allowed_calendar_sharing_roles(
        self,
        user_id: str,
        User: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function allowedCalendarSharingRoles.
        Outlook operation: GET /users/{user-id}/calendar/allowedCalendarSharingRoles(User='{User}')
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            User (str, required): User identifier: User
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.allowed_calendar_sharing_roles(_user='{_user}').get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_create_calendar_permissions(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to calendarPermissions for users.
        Outlook operation: POST /users/{user-id}/calendar/calendarPermissions
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.calendar_permissions.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_delete_calendar_permissions(
        self,
        user_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Delete calendarPermission.
        Outlook operation: DELETE /users/{user-id}/calendar/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarPermission_id (str, required): Outlook calendarPermission id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.calendar_permissions.by_calendarPermission_id(calendarPermission_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_get_calendar_permissions(
        self,
        user_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarPermission.
        Outlook operation: GET /users/{user-id}/calendar/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarPermission_id (str, required): Outlook calendarPermission 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.calendar_permissions.by_calendarPermission_id(calendarPermission_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_update_calendar_permissions(
        self,
        user_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Update calendarPermission.
        Outlook operation: PATCH /users/{user-id}/calendar/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarPermission_id (str, required): Outlook calendarPermission id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.calendar_permissions.by_calendarPermission_id(calendarPermission_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_list_calendar_view(
        self,
        user_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarView from users.
        Outlook operation: GET /users/{user-id}/calendar/calendarView
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.calendar_view.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_calendar_view_delta(
        self,
        user_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/calendar/calendarView/delta()
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.calendar_view.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_create_events(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to events for users.
        Outlook operation: POST /users/{user-id}/calendar/events
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_list_events(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get events from users.
        Outlook operation: GET /users/{user-id}/calendar/events
        Operation type: calendar
        Args:
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_events_delta(
        self,
        user_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/calendar/events/delta()
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_delete_events(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property events for users.
        Outlook operation: DELETE /users/{user-id}/calendar/events/{event-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_get_events(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get events from users.
        Outlook operation: GET /users/{user-id}/calendar/events/{event-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_update_events(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property events in users.
        Outlook operation: PATCH /users/{user-id}/calendar/events/{event-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_events_event_accept(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action accept.
        Outlook operation: POST /users/{user-id}/calendar/events/{event-id}/accept
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_events_create_attachments(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for users.
        Outlook operation: POST /users/{user-id}/calendar/events/{event-id}/attachments
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_events_list_attachments(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from users.
        Outlook operation: GET /users/{user-id}/calendar/events/{event-id}/attachments
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_events_event_attachments_create_upload_session(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /users/{user-id}/calendar/events/{event-id}/attachments/createUploadSession
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_events_delete_attachments(
        self,
        user_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for users.
        Outlook operation: DELETE /users/{user-id}/calendar/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_events_get_attachments(
        self,
        user_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from users.
        Outlook operation: GET /users/{user-id}/calendar/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_events_get_calendar(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendar from users.
        Outlook operation: GET /users/{user-id}/calendar/events/{event-id}/calendar
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).calendar.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_events_event_cancel(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action cancel.
        Outlook operation: POST /users/{user-id}/calendar/events/{event-id}/cancel
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).cancel.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_events_event_decline(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action decline.
        Outlook operation: POST /users/{user-id}/calendar/events/{event-id}/decline
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).decline.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_events_event_dismiss_reminder(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action dismissReminder.
        Outlook operation: POST /users/{user-id}/calendar/events/{event-id}/dismissReminder
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).dismiss_reminder.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_events_event_forward(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /users/{user-id}/calendar/events/{event-id}/forward
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_events_list_instances(
        self,
        user_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get instances from users.
        Outlook operation: GET /users/{user-id}/calendar/events/{event-id}/instances
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).instances.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_events_event_instances_delta(
        self,
        user_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/calendar/events/{event-id}/instances/delta()
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).instances.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_events_event_permanent_delete(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/calendar/events/{event-id}/permanentDelete
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_events_event_snooze_reminder(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action snoozeReminder.
        Outlook operation: POST /users/{user-id}/calendar/events/{event-id}/snoozeReminder
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).snooze_reminder.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_events_event_tentatively_accept(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action tentativelyAccept.
        Outlook operation: POST /users/{user-id}/calendar/events/{event-id}/tentativelyAccept
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.events.by_event_id(event_id).tentatively_accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_get_schedule(
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action getSchedule.
        Outlook operation: POST /users/{user-id}/calendar/getSchedule
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.get_schedule.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_permanent_delete(
        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,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/calendar/permanentDelete
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar.permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_create_calendar_groups(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to calendarGroups for users.
        Outlook operation: POST /users/{user-id}/calendarGroups
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_list_calendar_groups(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarGroups from users.
        Outlook operation: GET /users/{user-id}/calendarGroups
        Operation type: calendar
        Args:
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_delete_calendar_groups(
        self,
        user_id: str,
        calendarGroup_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property calendarGroups for users.
        Outlook operation: DELETE /users/{user-id}/calendarGroups/{calendarGroup-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_get_calendar_groups(
        self,
        user_id: str,
        calendarGroup_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarGroups from users.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_update_calendar_groups(
        self,
        user_id: str,
        calendarGroup_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property calendarGroups in users.
        Outlook operation: PATCH /users/{user-id}/calendarGroups/{calendarGroup-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_create_calendars(
        self,
        user_id: str,
        calendarGroup_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to calendars for users.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_list_calendars(
        self,
        user_id: str,
        calendarGroup_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendars from users.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_delete_calendars(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property calendars for users.
        Outlook operation: DELETE /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_get_calendars(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendars from users.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_update_calendars(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property calendars in users.
        Outlook operation: PATCH /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_allowed_calendar_sharing_roles(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        User: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function allowedCalendarSharingRoles.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/allowedCalendarSharingRoles(User='{User}')
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            User (str, required): User identifier: User
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).allowed_calendar_sharing_roles(_user='{_user}').get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_create_calendar_permissions(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to calendarPermissions for users.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/calendarPermissions
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).calendar_permissions.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_list_calendar_permissions(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarPermissions from users.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/calendarPermissions
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).calendar_permissions.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_delete_calendar_permissions(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property calendarPermissions for users.
        Outlook operation: DELETE /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            calendarPermission_id (str, required): Outlook calendarPermission id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).calendar_permissions.by_calendarPermission_id(calendarPermission_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_get_calendar_permissions(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarPermissions from users.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            calendarPermission_id (str, required): Outlook calendarPermission 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).calendar_permissions.by_calendarPermission_id(calendarPermission_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_update_calendar_permissions(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property calendarPermissions in users.
        Outlook operation: PATCH /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            calendarPermission_id (str, required): Outlook calendarPermission id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).calendar_permissions.by_calendarPermission_id(calendarPermission_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_list_calendar_view(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarView from users.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/calendarView
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).calendar_view.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_calendar_view_delta(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/calendarView/delta()
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).calendar_view.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_create_events(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to events for users.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_list_events(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Get events from users.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_events_delta(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/delta()
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_delete_events(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property events for users.
        Outlook operation: DELETE /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_get_events(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get events from users.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_update_events(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property events in users.
        Outlook operation: PATCH /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_events_event_accept(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action accept.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/accept
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_events_create_attachments(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for users.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/attachments
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_events_list_attachments(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from users.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/attachments
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_events_event_attachments_create_upload_session(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/attachments/createUploadSession
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_events_delete_attachments(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for users.
        Outlook operation: DELETE /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_events_get_attachments(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from users.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_events_get_calendar(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendar from users.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/calendar
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).calendar.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_events_event_cancel(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action cancel.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/cancel
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).cancel.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_events_event_decline(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action decline.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/decline
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).decline.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_events_event_dismiss_reminder(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action dismissReminder.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/dismissReminder
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).dismiss_reminder.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_events_event_forward(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/forward
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendar_groups_calendars_events_list_instances(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get instances from users.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/instances
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).instances.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_events_event_instances_delta(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/instances/delta()
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).instances.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_events_event_permanent_delete(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/permanentDelete
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_events_event_snooze_reminder(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action snoozeReminder.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/snoozeReminder
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).snooze_reminder.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_events_event_tentatively_accept(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action tentativelyAccept.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/events/{event-id}/tentativelyAccept
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).tentatively_accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_get_schedule(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action getSchedule.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/getSchedule
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).get_schedule.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_groups_calendar_group_calendars_calendar_permanent_delete(
        self,
        user_id: str,
        calendarGroup_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/calendarGroups/{calendarGroup-id}/calendars/{calendar-id}/permanentDelete
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendarGroup_id (str, required): Outlook calendarGroup id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_groups.by_calendarGroup_id(calendarGroup_id).calendars.by_calendar_id(calendar_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_list_calendar_view(
        self,
        user_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarView from users.
        Outlook operation: GET /users/{user-id}/calendarView
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_view.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendar_view_delta(
        self,
        user_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/calendarView/delta()
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendar_view.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_create_calendars(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to calendars for users.
        Outlook operation: POST /users/{user-id}/calendars
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_list_calendars(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get calendars from users.
        Outlook operation: GET /users/{user-id}/calendars
        Operation type: calendar
        Args:
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_delete_calendars(
        self,
        user_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property calendars for users.
        Outlook operation: DELETE /users/{user-id}/calendars/{calendar-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_get_calendars(
        self,
        user_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendars from users.
        Outlook operation: GET /users/{user-id}/calendars/{calendar-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_update_calendars(
        self,
        user_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property calendars in users.
        Outlook operation: PATCH /users/{user-id}/calendars/{calendar-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_allowed_calendar_sharing_roles(
        self,
        user_id: str,
        calendar_id: str,
        User: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function allowedCalendarSharingRoles.
        Outlook operation: GET /users/{user-id}/calendars/{calendar-id}/allowedCalendarSharingRoles(User='{User}')
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            User (str, required): User identifier: User
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).allowed_calendar_sharing_roles(_user='{_user}').get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_create_calendar_permissions(
        self,
        user_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to calendarPermissions for users.
        Outlook operation: POST /users/{user-id}/calendars/{calendar-id}/calendarPermissions
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).calendar_permissions.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_list_calendar_permissions(
        self,
        user_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarPermissions from users.
        Outlook operation: GET /users/{user-id}/calendars/{calendar-id}/calendarPermissions
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).calendar_permissions.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_delete_calendar_permissions(
        self,
        user_id: str,
        calendar_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property calendarPermissions for users.
        Outlook operation: DELETE /users/{user-id}/calendars/{calendar-id}/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            calendarPermission_id (str, required): Outlook calendarPermission id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).calendar_permissions.by_calendarPermission_id(calendarPermission_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_get_calendar_permissions(
        self,
        user_id: str,
        calendar_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarPermissions from users.
        Outlook operation: GET /users/{user-id}/calendars/{calendar-id}/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            calendarPermission_id (str, required): Outlook calendarPermission 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).calendar_permissions.by_calendarPermission_id(calendarPermission_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_update_calendar_permissions(
        self,
        user_id: str,
        calendar_id: str,
        calendarPermission_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property calendarPermissions in users.
        Outlook operation: PATCH /users/{user-id}/calendars/{calendar-id}/calendarPermissions/{calendarPermission-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            calendarPermission_id (str, required): Outlook calendarPermission id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).calendar_permissions.by_calendarPermission_id(calendarPermission_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_list_calendar_view(
        self,
        user_id: str,
        calendar_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get calendarView from users.
        Outlook operation: GET /users/{user-id}/calendars/{calendar-id}/calendarView
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).calendar_view.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_calendar_view_delta(
        self,
        user_id: str,
        calendar_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/calendars/{calendar-id}/calendarView/delta()
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).calendar_view.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_create_events(
        self,
        user_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to events for users.
        Outlook operation: POST /users/{user-id}/calendars/{calendar-id}/events
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_list_events(
        self,
        user_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Get events from users.
        Outlook operation: GET /users/{user-id}/calendars/{calendar-id}/events
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_events_delta(
        self,
        user_id: str,
        calendar_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/calendars/{calendar-id}/events/delta()
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_delete_events(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property events for users.
        Outlook operation: DELETE /users/{user-id}/calendars/{calendar-id}/events/{event-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_get_events(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get events from users.
        Outlook operation: GET /users/{user-id}/calendars/{calendar-id}/events/{event-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_update_events(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property events in users.
        Outlook operation: PATCH /users/{user-id}/calendars/{calendar-id}/events/{event-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_events_event_accept(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action accept.
        Outlook operation: POST /users/{user-id}/calendars/{calendar-id}/events/{event-id}/accept
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_events_create_attachments(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for users.
        Outlook operation: POST /users/{user-id}/calendars/{calendar-id}/events/{event-id}/attachments
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_events_list_attachments(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from users.
        Outlook operation: GET /users/{user-id}/calendars/{calendar-id}/events/{event-id}/attachments
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_events_event_attachments_create_upload_session(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /users/{user-id}/calendars/{calendar-id}/events/{event-id}/attachments/createUploadSession
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_events_delete_attachments(
        self,
        user_id: str,
        calendar_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for users.
        Outlook operation: DELETE /users/{user-id}/calendars/{calendar-id}/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_events_get_attachments(
        self,
        user_id: str,
        calendar_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from users.
        Outlook operation: GET /users/{user-id}/calendars/{calendar-id}/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_events_get_calendar(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendar from users.
        Outlook operation: GET /users/{user-id}/calendars/{calendar-id}/events/{event-id}/calendar
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).calendar.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_events_event_cancel(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action cancel.
        Outlook operation: POST /users/{user-id}/calendars/{calendar-id}/events/{event-id}/cancel
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).cancel.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_events_event_decline(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action decline.
        Outlook operation: POST /users/{user-id}/calendars/{calendar-id}/events/{event-id}/decline
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).decline.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_events_event_dismiss_reminder(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action dismissReminder.
        Outlook operation: POST /users/{user-id}/calendars/{calendar-id}/events/{event-id}/dismissReminder
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).dismiss_reminder.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_events_event_forward(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /users/{user-id}/calendars/{calendar-id}/events/{event-id}/forward
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_calendars_events_list_instances(
        self,
        user_id: str,
        calendar_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get instances from users.
        Outlook operation: GET /users/{user-id}/calendars/{calendar-id}/events/{event-id}/instances
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).instances.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_events_event_instances_delta(
        self,
        user_id: str,
        calendar_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/calendars/{calendar-id}/events/{event-id}/instances/delta()
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).instances.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_events_event_permanent_delete(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/calendars/{calendar-id}/events/{event-id}/permanentDelete
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_events_event_snooze_reminder(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action snoozeReminder.
        Outlook operation: POST /users/{user-id}/calendars/{calendar-id}/events/{event-id}/snoozeReminder
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).snooze_reminder.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_events_event_tentatively_accept(
        self,
        user_id: str,
        calendar_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action tentativelyAccept.
        Outlook operation: POST /users/{user-id}/calendars/{calendar-id}/events/{event-id}/tentativelyAccept
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).events.by_event_id(event_id).tentatively_accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_get_schedule(
        self,
        user_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action getSchedule.
        Outlook operation: POST /users/{user-id}/calendars/{calendar-id}/getSchedule
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).get_schedule.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_calendars_calendar_permanent_delete(
        self,
        user_id: str,
        calendar_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/calendars/{calendar-id}/permanentDelete
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            calendar_id (str, required): Outlook calendar id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).calendars.by_calendar_id(calendar_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_create_events(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to events for users.
        Outlook operation: POST /users/{user-id}/events
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).events.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_list_events(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get events from users.
        Outlook operation: GET /users/{user-id}/events
        Operation type: calendar
        Args:
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).events.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_events_delta(
        self,
        user_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/events/delta()
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).events.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_delete_events(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property events for users.
        Outlook operation: DELETE /users/{user-id}/events/{event-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_get_events(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get events from users.
        Outlook operation: GET /users/{user-id}/events/{event-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_update_events(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property events in users.
        Outlook operation: PATCH /users/{user-id}/events/{event-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_events_event_accept(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action accept.
        Outlook operation: POST /users/{user-id}/events/{event-id}/accept
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_events_create_attachments(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for users.
        Outlook operation: POST /users/{user-id}/events/{event-id}/attachments
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_events_list_attachments(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from users.
        Outlook operation: GET /users/{user-id}/events/{event-id}/attachments
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_events_event_attachments_create_upload_session(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /users/{user-id}/events/{event-id}/attachments/createUploadSession
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_events_delete_attachments(
        self,
        user_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for users.
        Outlook operation: DELETE /users/{user-id}/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_events_get_attachments(
        self,
        user_id: str,
        event_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from users.
        Outlook operation: GET /users/{user-id}/events/{event-id}/attachments/{attachment-id}
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_events_get_calendar(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Get calendar from users.
        Outlook operation: GET /users/{user-id}/events/{event-id}/calendar
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).calendar.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_events_event_cancel(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action cancel.
        Outlook operation: POST /users/{user-id}/events/{event-id}/cancel
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).cancel.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_events_event_decline(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action decline.
        Outlook operation: POST /users/{user-id}/events/{event-id}/decline
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).decline.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_events_event_dismiss_reminder(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action dismissReminder.
        Outlook operation: POST /users/{user-id}/events/{event-id}/dismissReminder
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).dismiss_reminder.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_events_event_forward(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action forward.
        Outlook operation: POST /users/{user-id}/events/{event-id}/forward
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).forward.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_events_list_instances(
        self,
        user_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Get instances from users.
        Outlook operation: GET /users/{user-id}/events/{event-id}/instances
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T19:00:00-08:00
            endDateTime (str, required): The end date and time of the time range, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).instances.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_events_event_instances_delta(
        self,
        user_id: str,
        event_id: str,
        startDateTime: str,
        endDateTime: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/events/{event-id}/instances/delta()
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            startDateTime (str, required): The start date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            endDateTime (str, required): The end date and time of the time range in the function, represented in ISO 8601 format. For example, 2019-11-08T20:00:00-08:00
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).instances.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_events_event_permanent_delete(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/events/{event-id}/permanentDelete
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_events_event_snooze_reminder(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action snoozeReminder.
        Outlook operation: POST /users/{user-id}/events/{event-id}/snoozeReminder
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).snooze_reminder.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_events_event_tentatively_accept(
        self,
        user_id: str,
        event_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action tentativelyAccept.
        Outlook operation: POST /users/{user-id}/events/{event-id}/tentativelyAccept
        Operation type: calendar
        Args:
            user_id (str, required): Outlook user id identifier
            event_id (str, required): Outlook event id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).events.by_event_id(event_id).tentatively_accept.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    # ========== CONTACTS OPERATIONS (81 methods) ==========

    async def contacts_org_contact_list_org_contact(
        self,
        ConsistencyLevel: Optional[str] = None,
        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
    ) -> OutlookCalendarContactsResponse:
        """List orgContacts.
        Outlook operation: GET /contacts
        Operation type: contacts
        Args:
            ConsistencyLevel (str, optional): Indicates the requested consistency level. Documentation URL: https://docs.microsoft.com/graph/aad-advanced-queries
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.contacts.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def contacts_delta(
        self,
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /contacts/delta()
        Operation type: contacts
        Args:
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.contacts.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def contacts_validate_properties(
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action validateProperties.
        Outlook operation: POST /contacts/validateProperties
        Operation type: contacts
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.contacts.validate_properties.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def contacts_org_contact_get_org_contact(
        self,
        orgContact_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
    ) -> OutlookCalendarContactsResponse:
        """Get orgContact.
        Outlook operation: GET /contacts/{orgContact-id}
        Operation type: contacts
        Args:
            orgContact_id (str, required): Outlook orgContact 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.contacts.by_contact_id(orgContact_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def contacts_org_contact_check_member_objects(
        self,
        orgContact_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action checkMemberObjects.
        Outlook operation: POST /contacts/{orgContact-id}/checkMemberObjects
        Operation type: contacts
        Args:
            orgContact_id (str, required): Outlook orgContact id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.contacts.by_contact_id(orgContact_id).check_member_objects.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def contacts_list_direct_reports(
        self,
        orgContact_id: str,
        ConsistencyLevel: Optional[str] = None,
        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
    ) -> OutlookCalendarContactsResponse:
        """List directReports.
        Outlook operation: GET /contacts/{orgContact-id}/directReports
        Operation type: contacts
        Args:
            orgContact_id (str, required): Outlook orgContact id identifier
            ConsistencyLevel (str, optional): Indicates the requested consistency level. Documentation URL: https://docs.microsoft.com/graph/aad-advanced-queries
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.contacts.by_contact_id(orgContact_id).direct_reports.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def contacts_get_manager(
        self,
        orgContact_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
    ) -> OutlookCalendarContactsResponse:
        """Get manager.
        Outlook operation: GET /contacts/{orgContact-id}/manager
        Operation type: contacts
        Args:
            orgContact_id (str, required): Outlook orgContact 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.contacts.by_contact_id(orgContact_id).manager.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def contacts_list_member_of(
        self,
        orgContact_id: str,
        ConsistencyLevel: Optional[str] = None,
        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
    ) -> OutlookCalendarContactsResponse:
        """List memberOf.
        Outlook operation: GET /contacts/{orgContact-id}/memberOf
        Operation type: contacts
        Args:
            orgContact_id (str, required): Outlook orgContact id identifier
            ConsistencyLevel (str, optional): Indicates the requested consistency level. Documentation URL: https://docs.microsoft.com/graph/aad-advanced-queries
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.contacts.by_contact_id(orgContact_id).member_of.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def contacts_org_contact_retry_service_provisioning(
        self,
        orgContact_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action retryServiceProvisioning.
        Outlook operation: POST /contacts/{orgContact-id}/retryServiceProvisioning
        Operation type: contacts
        Args:
            orgContact_id (str, required): Outlook orgContact id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.contacts.by_contact_id(orgContact_id).retry_service_provisioning.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def contacts_list_service_provisioning_errors(
        self,
        orgContact_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
    ) -> OutlookCalendarContactsResponse:
        """Get serviceProvisioningErrors property value.
        Outlook operation: GET /contacts/{orgContact-id}/serviceProvisioningErrors
        Operation type: contacts
        Args:
            orgContact_id (str, required): Outlook orgContact 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.contacts.by_contact_id(orgContact_id).service_provisioning_errors.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def contacts_list_transitive_member_of(
        self,
        orgContact_id: str,
        ConsistencyLevel: Optional[str] = None,
        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
    ) -> OutlookCalendarContactsResponse:
        """List transitiveMemberOf.
        Outlook operation: GET /contacts/{orgContact-id}/transitiveMemberOf
        Operation type: contacts
        Args:
            orgContact_id (str, required): Outlook orgContact id identifier
            ConsistencyLevel (str, optional): Indicates the requested consistency level. Documentation URL: https://docs.microsoft.com/graph/aad-advanced-queries
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.contacts.by_contact_id(orgContact_id).transitive_member_of.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_create_contact_folders(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create ContactFolder.
        Outlook operation: POST /me/contactFolders
        Operation type: contacts
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_list_contact_folders(
        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
    ) -> OutlookCalendarContactsResponse:
        """List contactFolders.
        Outlook operation: GET /me/contactFolders
        Operation type: contacts
        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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactFoldersRequestBuilder.ContactFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contact_folders.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_delta(
        self,
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/contactFolders/delta()
        Operation type: contacts
        Args:
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactFoldersRequestBuilder.ContactFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contact_folders.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_delete_contact_folders(
        self,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Delete contactFolder.
        Outlook operation: DELETE /me/contactFolders/{contactFolder-id}
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_get_contact_folders(
        self,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Get contactFolder.
        Outlook operation: GET /me/contactFolders/{contactFolder-id}
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactFoldersRequestBuilder.ContactFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_update_contact_folders(
        self,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Update contactfolder.
        Outlook operation: PATCH /me/contactFolders/{contactFolder-id}
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_create_child_folders(
        self,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Create ContactFolder.
        Outlook operation: POST /me/contactFolders/{contactFolder-id}/childFolders
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).child_folders.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_list_child_folders(
        self,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """List childFolders.
        Outlook operation: GET /me/contactFolders/{contactFolder-id}/childFolders
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactFoldersRequestBuilder.ContactFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).child_folders.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_contact_folder_child_folders_delta(
        self,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/contactFolders/{contactFolder-id}/childFolders/delta()
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactFoldersRequestBuilder.ContactFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).child_folders.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_delete_child_folders(
        self,
        contactFolder_id: str,
        contactFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property childFolders for me.
        Outlook operation: DELETE /me/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_get_child_folders(
        self,
        contactFolder_id: str,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Get childFolders from me.
        Outlook operation: GET /me/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactFoldersRequestBuilder.ContactFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_update_child_folders(
        self,
        contactFolder_id: str,
        contactFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property childFolders in me.
        Outlook operation: PATCH /me/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_child_folders_create_contacts(
        self,
        contactFolder_id: str,
        contactFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to contacts for me.
        Outlook operation: POST /me/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/contacts
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).contacts.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_child_folders_list_contacts(
        self,
        contactFolder_id: str,
        contactFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Get contacts from me.
        Outlook operation: GET /me/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/contacts
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactFoldersRequestBuilder.ContactFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).contacts.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_contact_folder_child_folders_contact_folder_contacts_delta(
        self,
        contactFolder_id: str,
        contactFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/contacts/delta()
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactFoldersRequestBuilder.ContactFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).contacts.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_child_folders_delete_contacts(
        self,
        contactFolder_id: str,
        contactFolder_id1: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property contacts for me.
        Outlook operation: DELETE /me/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/contacts/{contact-id}
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            contact_id (str, required): Outlook contact id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).contacts.by_contact_id(contact_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_child_folders_get_contacts(
        self,
        contactFolder_id: str,
        contactFolder_id1: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Get contacts from me.
        Outlook operation: GET /me/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/contacts/{contact-id}
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            contact_id (str, required): Outlook contact 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactFoldersRequestBuilder.ContactFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).contacts.by_contact_id(contact_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_child_folders_update_contacts(
        self,
        contactFolder_id: str,
        contactFolder_id1: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property contacts in me.
        Outlook operation: PATCH /me/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/contacts/{contact-id}
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            contact_id (str, required): Outlook contact id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).contacts.by_contact_id(contact_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_contact_folder_child_folders_contact_folder_contacts_contact_permanent_delete(
        self,
        contactFolder_id: str,
        contactFolder_id1: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/contacts/{contact-id}/permanentDelete
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            contact_id (str, required): Outlook contact id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).contacts.by_contact_id(contact_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_contact_folder_child_folders_contact_folder_permanent_delete(
        self,
        contactFolder_id: str,
        contactFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/permanentDelete
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_create_contacts(
        self,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Create contact.
        Outlook operation: POST /me/contactFolders/{contactFolder-id}/contacts
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).contacts.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_list_contacts(
        self,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """List contacts.
        Outlook operation: GET /me/contactFolders/{contactFolder-id}/contacts
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactFoldersRequestBuilder.ContactFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).contacts.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_contact_folder_contacts_delta(
        self,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/contactFolders/{contactFolder-id}/contacts/delta()
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactFoldersRequestBuilder.ContactFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).contacts.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_delete_contacts(
        self,
        contactFolder_id: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property contacts for me.
        Outlook operation: DELETE /me/contactFolders/{contactFolder-id}/contacts/{contact-id}
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contact_id (str, required): Outlook contact id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).contacts.by_contact_id(contact_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_get_contacts(
        self,
        contactFolder_id: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Get contacts from me.
        Outlook operation: GET /me/contactFolders/{contactFolder-id}/contacts/{contact-id}
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contact_id (str, required): Outlook contact 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactFoldersRequestBuilder.ContactFoldersRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).contacts.by_contact_id(contact_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_update_contacts(
        self,
        contactFolder_id: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property contacts in me.
        Outlook operation: PATCH /me/contactFolders/{contactFolder-id}/contacts/{contact-id}
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contact_id (str, required): Outlook contact id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).contacts.by_contact_id(contact_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_contact_folder_contacts_contact_permanent_delete(
        self,
        contactFolder_id: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/contactFolders/{contactFolder-id}/contacts/{contact-id}/permanentDelete
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contact_id (str, required): Outlook contact id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).contacts.by_contact_id(contact_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contact_folders_contact_folder_permanent_delete(
        self,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/contactFolders/{contactFolder-id}/permanentDelete
        Operation type: contacts
        Args:
            contactFolder_id (str, required): Outlook contactFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contact_folders.by_contact_folder_id(contactFolder_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_create_contacts(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create contact.
        Outlook operation: POST /me/contacts
        Operation type: contacts
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contacts.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_list_contacts(
        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
    ) -> OutlookCalendarContactsResponse:
        """List contacts.
        Outlook operation: GET /me/contacts
        Operation type: contacts
        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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactsRequestBuilder.ContactsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contacts.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contacts_delta(
        self,
        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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /me/contacts/delta()
        Operation type: contacts
        Args:
            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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactsRequestBuilder.ContactsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contacts.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_delete_contacts(
        self,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Delete contact.
        Outlook operation: DELETE /me/contacts/{contact-id}
        Operation type: contacts
        Args:
            contact_id (str, required): Outlook contact id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contacts.by_contact_id(contact_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_get_contacts(
        self,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Get contact.
        Outlook operation: GET /me/contacts/{contact-id}
        Operation type: contacts
        Args:
            contact_id (str, required): Outlook contact 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactsRequestBuilder.ContactsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.me.contacts.by_contact_id(contact_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_update_contacts(
        self,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Update contact.
        Outlook operation: PATCH /me/contacts/{contact-id}
        Operation type: contacts
        Args:
            contact_id (str, required): Outlook contact id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contacts.by_contact_id(contact_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_contacts_contact_permanent_delete(
        self,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /me/contacts/{contact-id}/permanentDelete
        Operation type: contacts
        Args:
            contact_id (str, required): Outlook contact id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.contacts.by_contact_id(contact_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_create_contact_folders(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to contactFolders for users.
        Outlook operation: POST /users/{user-id}/contactFolders
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_list_contact_folders(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get contactFolders from users.
        Outlook operation: GET /users/{user-id}/contactFolders
        Operation type: contacts
        Args:
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_contact_folders_delta(
        self,
        user_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/contactFolders/delta()
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_delete_contact_folders(
        self,
        user_id: str,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property contactFolders for users.
        Outlook operation: DELETE /users/{user-id}/contactFolders/{contactFolder-id}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_get_contact_folders(
        self,
        user_id: str,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Get contactFolders from users.
        Outlook operation: GET /users/{user-id}/contactFolders/{contactFolder-id}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_update_contact_folders(
        self,
        user_id: str,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property contactFolders in users.
        Outlook operation: PATCH /users/{user-id}/contactFolders/{contactFolder-id}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_create_child_folders(
        self,
        user_id: str,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to childFolders for users.
        Outlook operation: POST /users/{user-id}/contactFolders/{contactFolder-id}/childFolders
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).child_folders.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_list_child_folders(
        self,
        user_id: str,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Get childFolders from users.
        Outlook operation: GET /users/{user-id}/contactFolders/{contactFolder-id}/childFolders
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).child_folders.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_contact_folders_contact_folder_child_folders_delta(
        self,
        user_id: str,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/contactFolders/{contactFolder-id}/childFolders/delta()
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).child_folders.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_delete_child_folders(
        self,
        user_id: str,
        contactFolder_id: str,
        contactFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property childFolders for users.
        Outlook operation: DELETE /users/{user-id}/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_get_child_folders(
        self,
        user_id: str,
        contactFolder_id: str,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Get childFolders from users.
        Outlook operation: GET /users/{user-id}/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_update_child_folders(
        self,
        user_id: str,
        contactFolder_id: str,
        contactFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property childFolders in users.
        Outlook operation: PATCH /users/{user-id}/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_child_folders_create_contacts(
        self,
        user_id: str,
        contactFolder_id: str,
        contactFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to contacts for users.
        Outlook operation: POST /users/{user-id}/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/contacts
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).contacts.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_child_folders_list_contacts(
        self,
        user_id: str,
        contactFolder_id: str,
        contactFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Get contacts from users.
        Outlook operation: GET /users/{user-id}/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/contacts
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).contacts.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_contact_folders_contact_folder_child_folders_contact_folder_contacts_delta(
        self,
        user_id: str,
        contactFolder_id: str,
        contactFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/contacts/delta()
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).contacts.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_child_folders_delete_contacts(
        self,
        user_id: str,
        contactFolder_id: str,
        contactFolder_id1: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property contacts for users.
        Outlook operation: DELETE /users/{user-id}/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/contacts/{contact-id}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            contact_id (str, required): Outlook contact id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).contacts.by_contact_id(contact_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_child_folders_get_contacts(
        self,
        user_id: str,
        contactFolder_id: str,
        contactFolder_id1: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Get contacts from users.
        Outlook operation: GET /users/{user-id}/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/contacts/{contact-id}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            contact_id (str, required): Outlook contact 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).contacts.by_contact_id(contact_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_child_folders_update_contacts(
        self,
        user_id: str,
        contactFolder_id: str,
        contactFolder_id1: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property contacts in users.
        Outlook operation: PATCH /users/{user-id}/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/contacts/{contact-id}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            contact_id (str, required): Outlook contact id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).contacts.by_contact_id(contact_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_contact_folders_contact_folder_child_folders_contact_folder_contacts_contact_permanent_delete(
        self,
        user_id: str,
        contactFolder_id: str,
        contactFolder_id1: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/contacts/{contact-id}/permanentDelete
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            contact_id (str, required): Outlook contact id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).contacts.by_contact_id(contact_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_contact_folders_contact_folder_child_folders_contact_folder_permanent_delete(
        self,
        user_id: str,
        contactFolder_id: str,
        contactFolder_id1: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/contactFolders/{contactFolder-id}/childFolders/{contactFolder-id1}/permanentDelete
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contactFolder_id1 (str, required): Outlook contactFolder id1 identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).child_folders.by_childFolder_id(contactFolder_id1).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_create_contacts(
        self,
        user_id: str,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to contacts for users.
        Outlook operation: POST /users/{user-id}/contactFolders/{contactFolder-id}/contacts
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).contacts.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_list_contacts(
        self,
        user_id: str,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Get contacts from users.
        Outlook operation: GET /users/{user-id}/contactFolders/{contactFolder-id}/contacts
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).contacts.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_contact_folders_contact_folder_contacts_delta(
        self,
        user_id: str,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/contactFolders/{contactFolder-id}/contacts/delta()
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).contacts.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_delete_contacts(
        self,
        user_id: str,
        contactFolder_id: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property contacts for users.
        Outlook operation: DELETE /users/{user-id}/contactFolders/{contactFolder-id}/contacts/{contact-id}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contact_id (str, required): Outlook contact id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).contacts.by_contact_id(contact_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_get_contacts(
        self,
        user_id: str,
        contactFolder_id: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Get contacts from users.
        Outlook operation: GET /users/{user-id}/contactFolders/{contactFolder-id}/contacts/{contact-id}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contact_id (str, required): Outlook contact 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).contacts.by_contact_id(contact_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_contact_folders_update_contacts(
        self,
        user_id: str,
        contactFolder_id: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property contacts in users.
        Outlook operation: PATCH /users/{user-id}/contactFolders/{contactFolder-id}/contacts/{contact-id}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contact_id (str, required): Outlook contact id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).contacts.by_contact_id(contact_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_contact_folders_contact_folder_contacts_contact_permanent_delete(
        self,
        user_id: str,
        contactFolder_id: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/contactFolders/{contactFolder-id}/contacts/{contact-id}/permanentDelete
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            contact_id (str, required): Outlook contact id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).contacts.by_contact_id(contact_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_contact_folders_contact_folder_permanent_delete(
        self,
        user_id: str,
        contactFolder_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/contactFolders/{contactFolder-id}/permanentDelete
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contactFolder_id (str, required): Outlook contactFolder id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contact_folders.by_contact_folder_id(contactFolder_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_create_contacts(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to contacts for users.
        Outlook operation: POST /users/{user-id}/contacts
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contacts.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_list_contacts(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get contacts from users.
        Outlook operation: GET /users/{user-id}/contacts
        Operation type: contacts
        Args:
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactsRequestBuilder.ContactsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).contacts.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_contacts_delta(
        self,
        user_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function delta.
        Outlook operation: GET /users/{user-id}/contacts/delta()
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactsRequestBuilder.ContactsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).contacts.delta().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_delete_contacts(
        self,
        user_id: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property contacts for users.
        Outlook operation: DELETE /users/{user-id}/contacts/{contact-id}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contact_id (str, required): Outlook contact id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contacts.by_contact_id(contact_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_get_contacts(
        self,
        user_id: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Get contacts from users.
        Outlook operation: GET /users/{user-id}/contacts/{contact-id}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contact_id (str, required): Outlook contact 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        try:
            # Use typed query parameters
            query_params = ContactsRequestBuilder.ContactsRequestBuilderGetQueryParameters()

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

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

            if headers:
                config.headers = headers

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

            response = await self.client.users.by_user_id(user_id).contacts.by_contact_id(contact_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_update_contacts(
        self,
        user_id: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property contacts in users.
        Outlook operation: PATCH /users/{user-id}/contacts/{contact-id}
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contact_id (str, required): Outlook contact id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contacts.by_contact_id(contact_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_contacts_contact_permanent_delete(
        self,
        user_id: str,
        contact_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action permanentDelete.
        Outlook operation: POST /users/{user-id}/contacts/{contact-id}/permanentDelete
        Operation type: contacts
        Args:
            user_id (str, required): Outlook user id identifier
            contact_id (str, required): Outlook contact id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).contacts.by_contact_id(contact_id).permanent_delete.post(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    # ========== ATTACHMENTS OPERATIONS (20 methods) ==========

    async def groups_conversations_threads_posts_create_attachments(
        self,
        group_id: str,
        conversation_id: str,
        conversationThread_id: str,
        post_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for groups.
        Outlook operation: POST /groups/{group-id}/conversations/{conversation-id}/threads/{conversationThread-id}/posts/{post-id}/attachments
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversation_id (str, required): Outlook conversation id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).conversations.by_conversation_id(conversation_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_conversations_threads_posts_list_attachments(
        self,
        group_id: str,
        conversation_id: str,
        conversationThread_id: str,
        post_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from groups.
        Outlook operation: GET /groups/{group-id}/conversations/{conversation-id}/threads/{conversationThread-id}/posts/{post-id}/attachments
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversation_id (str, required): Outlook conversation id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).conversations.by_conversation_id(conversation_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_conversations_conversation_threads_conversation_thread_posts_post_attachments_create_upload_session(
        self,
        group_id: str,
        conversation_id: str,
        conversationThread_id: str,
        post_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /groups/{group-id}/conversations/{conversation-id}/threads/{conversationThread-id}/posts/{post-id}/attachments/createUploadSession
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversation_id (str, required): Outlook conversation id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).conversations.by_conversation_id(conversation_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_conversations_threads_posts_delete_attachments(
        self,
        group_id: str,
        conversation_id: str,
        conversationThread_id: str,
        post_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for groups.
        Outlook operation: DELETE /groups/{group-id}/conversations/{conversation-id}/threads/{conversationThread-id}/posts/{post-id}/attachments/{attachment-id}
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversation_id (str, required): Outlook conversation id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).conversations.by_conversation_id(conversation_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_conversations_threads_posts_get_attachments(
        self,
        group_id: str,
        conversation_id: str,
        conversationThread_id: str,
        post_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from groups.
        Outlook operation: GET /groups/{group-id}/conversations/{conversation-id}/threads/{conversationThread-id}/posts/{post-id}/attachments/{attachment-id}
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversation_id (str, required): Outlook conversation id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).conversations.by_conversation_id(conversation_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_conversations_threads_posts_in_reply_to_create_attachments(
        self,
        group_id: str,
        conversation_id: str,
        conversationThread_id: str,
        post_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for groups.
        Outlook operation: POST /groups/{group-id}/conversations/{conversation-id}/threads/{conversationThread-id}/posts/{post-id}/inReplyTo/attachments
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversation_id (str, required): Outlook conversation id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).conversations.by_conversation_id(conversation_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).in_reply_to.attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_conversations_threads_posts_in_reply_to_list_attachments(
        self,
        group_id: str,
        conversation_id: str,
        conversationThread_id: str,
        post_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from groups.
        Outlook operation: GET /groups/{group-id}/conversations/{conversation-id}/threads/{conversationThread-id}/posts/{post-id}/inReplyTo/attachments
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversation_id (str, required): Outlook conversation id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).conversations.by_conversation_id(conversation_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).in_reply_to.attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_conversations_conversation_threads_conversation_thread_posts_post_in_reply_to_attachments_create_upload_session(
        self,
        group_id: str,
        conversation_id: str,
        conversationThread_id: str,
        post_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /groups/{group-id}/conversations/{conversation-id}/threads/{conversationThread-id}/posts/{post-id}/inReplyTo/attachments/createUploadSession
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversation_id (str, required): Outlook conversation id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).conversations.by_conversation_id(conversation_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).in_reply_to.attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_conversations_threads_posts_in_reply_to_delete_attachments(
        self,
        group_id: str,
        conversation_id: str,
        conversationThread_id: str,
        post_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for groups.
        Outlook operation: DELETE /groups/{group-id}/conversations/{conversation-id}/threads/{conversationThread-id}/posts/{post-id}/inReplyTo/attachments/{attachment-id}
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversation_id (str, required): Outlook conversation id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).conversations.by_conversation_id(conversation_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).in_reply_to.attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_conversations_threads_posts_in_reply_to_get_attachments(
        self,
        group_id: str,
        conversation_id: str,
        conversationThread_id: str,
        post_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from groups.
        Outlook operation: GET /groups/{group-id}/conversations/{conversation-id}/threads/{conversationThread-id}/posts/{post-id}/inReplyTo/attachments/{attachment-id}
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversation_id (str, required): Outlook conversation id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).conversations.by_conversation_id(conversation_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).in_reply_to.attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_threads_posts_create_attachments(
        self,
        group_id: str,
        conversationThread_id: str,
        post_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for groups.
        Outlook operation: POST /groups/{group-id}/threads/{conversationThread-id}/posts/{post-id}/attachments
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_threads_posts_list_attachments(
        self,
        group_id: str,
        conversationThread_id: str,
        post_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
    ) -> OutlookCalendarContactsResponse:
        """List attachments.
        Outlook operation: GET /groups/{group-id}/threads/{conversationThread-id}/posts/{post-id}/attachments
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_threads_conversation_thread_posts_post_attachments_create_upload_session(
        self,
        group_id: str,
        conversationThread_id: str,
        post_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /groups/{group-id}/threads/{conversationThread-id}/posts/{post-id}/attachments/createUploadSession
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_threads_posts_delete_attachments(
        self,
        group_id: str,
        conversationThread_id: str,
        post_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for groups.
        Outlook operation: DELETE /groups/{group-id}/threads/{conversationThread-id}/posts/{post-id}/attachments/{attachment-id}
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_threads_posts_get_attachments(
        self,
        group_id: str,
        conversationThread_id: str,
        post_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from groups.
        Outlook operation: GET /groups/{group-id}/threads/{conversationThread-id}/posts/{post-id}/attachments/{attachment-id}
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_threads_posts_in_reply_to_create_attachments(
        self,
        group_id: str,
        conversationThread_id: str,
        post_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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to attachments for groups.
        Outlook operation: POST /groups/{group-id}/threads/{conversationThread-id}/posts/{post-id}/inReplyTo/attachments
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).in_reply_to.attachments.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_threads_posts_in_reply_to_list_attachments(
        self,
        group_id: str,
        conversationThread_id: str,
        post_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from groups.
        Outlook operation: GET /groups/{group-id}/threads/{conversationThread-id}/posts/{post-id}/inReplyTo/attachments
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).in_reply_to.attachments.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_group_threads_conversation_thread_posts_post_in_reply_to_attachments_create_upload_session(
        self,
        group_id: str,
        conversationThread_id: str,
        post_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
    ) -> OutlookCalendarContactsResponse:
        """Invoke action createUploadSession.
        Outlook operation: POST /groups/{group-id}/threads/{conversationThread-id}/posts/{post-id}/inReplyTo/attachments/createUploadSession
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).in_reply_to.attachments.create_upload_session.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_threads_posts_in_reply_to_delete_attachments(
        self,
        group_id: str,
        conversationThread_id: str,
        post_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property attachments for groups.
        Outlook operation: DELETE /groups/{group-id}/threads/{conversationThread-id}/posts/{post-id}/inReplyTo/attachments/{attachment-id}
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            attachment_id (str, required): Outlook attachment id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).in_reply_to.attachments.by_attachment_id(attachment_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_threads_posts_in_reply_to_get_attachments(
        self,
        group_id: str,
        conversationThread_id: str,
        post_id: str,
        attachment_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
    ) -> OutlookCalendarContactsResponse:
        """Get attachments from groups.
        Outlook operation: GET /groups/{group-id}/threads/{conversationThread-id}/posts/{post-id}/inReplyTo/attachments/{attachment-id}
        Operation type: attachments
        Args:
            group_id (str, required): Outlook group id identifier
            conversationThread_id (str, required): Outlook conversationThread id identifier
            post_id (str, required): Outlook post id identifier
            attachment_id (str, required): Outlook attachment 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.groups.by_group_id(group_id).threads.by_thread_id(conversationThread_id).posts.by_post_id(post_id).in_reply_to.attachments.by_attachment_id(attachment_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    # ========== GROUP CONVERSATIONS OPERATIONS (Phase 2) ==========

    async def groups_list_conversations(
        self,
        group_id: str,
        select: Optional[List[str]] = None,
        filter: Optional[str] = None,
        top: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        """List all conversations in a group.
        Outlook operation: GET /groups/{group-id}/conversations
        Args:
            group_id (str, required): Group identifier
            select (optional): Select specific properties to return
            filter (optional): Filter the results using OData syntax
            top (optional): Limit number of results returned
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        try:
            # Build query parameters
            query_params = RequestConfiguration()

            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if filter:
                query_params.filter = filter
            if top is not None:
                query_params.top = top

            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

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

    async def groups_list_threads(
        self,
        group_id: str,
        select: Optional[List[str]] = None,
        filter: Optional[str] = None,
        top: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        """List all threads in a group (across all conversations).
        Outlook operation: GET /groups/{group-id}/threads
        Args:
            group_id (str, required): Group identifier
            select (optional): Select specific properties to return
            filter (optional): Filter threads by OData query
            top (optional): Limit number of results returned
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        try:
            # Build query parameters
            query_params = RequestConfiguration()

            if select:
                query_params.select = select if isinstance(select, list) else [select]
            if filter:
                query_params.filter = filter
            if top is not None:
                query_params.top = top

            config = RequestConfiguration()
            config.query_parameters = query_params

            if headers:
                config.headers = headers

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

    async def groups_threads_list_posts(
        self,
        group_id: str,
        thread_id: str,
        select: Optional[List[str]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        """List all posts in a thread.
        Outlook operation: GET /groups/{group-id}/threads/{thread-id}/posts
        Args:
            group_id (str, required): Group identifier
            thread_id (str, required): Thread identifier
            select (optional): Select specific properties to return
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        try:
            config = RequestConfiguration()

            if headers:
                config.headers = headers

            response = await self.client.groups.by_group_id(group_id).threads.by_conversation_thread_id(thread_id).posts.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_threads_get_post(
        self,
        group_id: str,
        thread_id: str,
        post_id: str,
        select: Optional[List[str]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        """Get a single post from a thread.
        Outlook operation: GET /groups/{group-id}/threads/{thread-id}/posts/{post-id}
        Args:
            group_id (str, required): Group identifier
            thread_id (str, required): Thread identifier
            post_id (str, required): Post identifier
            select (optional): Select specific properties to return
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        try:
            config = RequestConfiguration()


            if headers:
                config.headers = headers

            response = await self.client.groups.by_group_id(group_id).threads.by_conversation_thread_id(thread_id).posts.by_post_id(post_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def groups_conversations_list_threads(
        self,
        group_id: str,
        conversation_id: str,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        """List threads in a specific conversation.
        Outlook operation: GET /groups/{group-id}/conversations/{conversation-id}/threads
        Args:
            group_id (str, required): Group identifier
            conversation_id (str, required): Conversation identifier
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        try:
            config = RequestConfiguration()

            if headers:
                config.headers = headers

            response = await self.client.groups.by_group_id(group_id).conversations.by_conversation_id(conversation_id).threads.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    # ========== EXTENSIONS OPERATIONS (1 methods) ==========

    async def applications_update_extension_properties(
        self,
        application_id: str,
        extensionProperty_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property extensionProperties in applications.
        Outlook operation: PATCH /applications/{application-id}/extensionProperties/{extensionProperty-id}
        Operation type: extensions
        Args:
            application_id (str, required): Outlook application id identifier
            extensionProperty_id (str, required): Outlook extensionProperty id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.applications.by_application_id(application_id).extension_properties.by_extensionPropertie_id(extensionProperty_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    # ========== RULES OPERATIONS (14 methods) ==========

    async def me_get_inference_classification(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get inferenceClassification from me.
        Outlook operation: GET /me/inferenceClassification
        Operation type: rules
        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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.inference_classification.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_update_inference_classification(
        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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property inferenceClassification in me.
        Outlook operation: PATCH /me/inferenceClassification
        Operation type: rules
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.inference_classification.patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_inference_classification_create_overrides(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create inferenceClassificationOverride.
        Outlook operation: POST /me/inferenceClassification/overrides
        Operation type: rules
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.inference_classification.overrides.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_inference_classification_list_overrides(
        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
    ) -> OutlookCalendarContactsResponse:
        """List overrides.
        Outlook operation: GET /me/inferenceClassification/overrides
        Operation type: rules
        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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.inference_classification.overrides.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_inference_classification_delete_overrides(
        self,
        inferenceClassificationOverride_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
    ) -> OutlookCalendarContactsResponse:
        """Delete inferenceClassificationOverride.
        Outlook operation: DELETE /me/inferenceClassification/overrides/{inferenceClassificationOverride-id}
        Operation type: rules
        Args:
            inferenceClassificationOverride_id (str, required): Outlook inferenceClassificationOverride id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.inference_classification.overrides.by_inference_classification_override_id(inferenceClassificationOverride_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_inference_classification_get_overrides(
        self,
        inferenceClassificationOverride_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
    ) -> OutlookCalendarContactsResponse:
        """Get overrides from me.
        Outlook operation: GET /me/inferenceClassification/overrides/{inferenceClassificationOverride-id}
        Operation type: rules
        Args:
            inferenceClassificationOverride_id (str, required): Outlook inferenceClassificationOverride 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.inference_classification.overrides.by_inference_classification_override_id(inferenceClassificationOverride_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_inference_classification_update_overrides(
        self,
        inferenceClassificationOverride_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
    ) -> OutlookCalendarContactsResponse:
        """Update inferenceclassificationoverride.
        Outlook operation: PATCH /me/inferenceClassification/overrides/{inferenceClassificationOverride-id}
        Operation type: rules
        Args:
            inferenceClassificationOverride_id (str, required): Outlook inferenceClassificationOverride id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.inference_classification.overrides.by_inference_classification_override_id(inferenceClassificationOverride_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_get_inference_classification(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get inferenceClassification from users.
        Outlook operation: GET /users/{user-id}/inferenceClassification
        Operation type: rules
        Args:
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).inference_classification.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_update_inference_classification(
        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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property inferenceClassification in users.
        Outlook operation: PATCH /users/{user-id}/inferenceClassification
        Operation type: rules
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).inference_classification.patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_inference_classification_create_overrides(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to overrides for users.
        Outlook operation: POST /users/{user-id}/inferenceClassification/overrides
        Operation type: rules
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).inference_classification.overrides.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_inference_classification_list_overrides(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get overrides from users.
        Outlook operation: GET /users/{user-id}/inferenceClassification/overrides
        Operation type: rules
        Args:
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).inference_classification.overrides.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_inference_classification_delete_overrides(
        self,
        user_id: str,
        inferenceClassificationOverride_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property overrides for users.
        Outlook operation: DELETE /users/{user-id}/inferenceClassification/overrides/{inferenceClassificationOverride-id}
        Operation type: rules
        Args:
            user_id (str, required): Outlook user id identifier
            inferenceClassificationOverride_id (str, required): Outlook inferenceClassificationOverride id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).inference_classification.overrides.by_inference_classification_override_id(inferenceClassificationOverride_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_inference_classification_get_overrides(
        self,
        user_id: str,
        inferenceClassificationOverride_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
    ) -> OutlookCalendarContactsResponse:
        """Get overrides from users.
        Outlook operation: GET /users/{user-id}/inferenceClassification/overrides/{inferenceClassificationOverride-id}
        Operation type: rules
        Args:
            user_id (str, required): Outlook user id identifier
            inferenceClassificationOverride_id (str, required): Outlook inferenceClassificationOverride 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).inference_classification.overrides.by_inference_classification_override_id(inferenceClassificationOverride_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_inference_classification_update_overrides(
        self,
        user_id: str,
        inferenceClassificationOverride_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property overrides in users.
        Outlook operation: PATCH /users/{user-id}/inferenceClassification/overrides/{inferenceClassificationOverride-id}
        Operation type: rules
        Args:
            user_id (str, required): Outlook user id identifier
            inferenceClassificationOverride_id (str, required): Outlook inferenceClassificationOverride id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).inference_classification.overrides.by_inference_classification_override_id(inferenceClassificationOverride_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    # ========== CATEGORIES OPERATIONS (10 methods) ==========

    async def me_outlook_create_master_categories(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create Outlook category.
        Outlook operation: POST /me/outlook/masterCategories
        Operation type: categories
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.outlook.master_categories.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_outlook_list_master_categories(
        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
    ) -> OutlookCalendarContactsResponse:
        """List masterCategories.
        Outlook operation: GET /me/outlook/masterCategories
        Operation type: categories
        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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.outlook.master_categories.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_outlook_delete_master_categories(
        self,
        outlookCategory_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
    ) -> OutlookCalendarContactsResponse:
        """Delete outlookCategory.
        Outlook operation: DELETE /me/outlook/masterCategories/{outlookCategory-id}
        Operation type: categories
        Args:
            outlookCategory_id (str, required): Outlook outlookCategory id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.outlook.master_categories.by_outlook_category_id(outlookCategory_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_outlook_get_master_categories(
        self,
        outlookCategory_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
    ) -> OutlookCalendarContactsResponse:
        """Get Outlook category.
        Outlook operation: GET /me/outlook/masterCategories/{outlookCategory-id}
        Operation type: categories
        Args:
            outlookCategory_id (str, required): Outlook outlookCategory 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.outlook.master_categories.by_outlook_category_id(outlookCategory_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_outlook_update_master_categories(
        self,
        outlookCategory_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
    ) -> OutlookCalendarContactsResponse:
        """Update outlookCategory.
        Outlook operation: PATCH /me/outlook/masterCategories/{outlookCategory-id}
        Operation type: categories
        Args:
            outlookCategory_id (str, required): Outlook outlookCategory id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.outlook.master_categories.by_outlook_category_id(outlookCategory_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_outlook_create_master_categories(
        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
    ) -> OutlookCalendarContactsResponse:
        """Create new navigation property to masterCategories for users.
        Outlook operation: POST /users/{user-id}/outlook/masterCategories
        Operation type: categories
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).outlook.master_categories.post(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_outlook_list_master_categories(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get masterCategories from users.
        Outlook operation: GET /users/{user-id}/outlook/masterCategories
        Operation type: categories
        Args:
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).outlook.master_categories.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_outlook_delete_master_categories(
        self,
        user_id: str,
        outlookCategory_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
    ) -> OutlookCalendarContactsResponse:
        """Delete navigation property masterCategories for users.
        Outlook operation: DELETE /users/{user-id}/outlook/masterCategories/{outlookCategory-id}
        Operation type: categories
        Args:
            user_id (str, required): Outlook user id identifier
            outlookCategory_id (str, required): Outlook outlookCategory id identifier
            If_Match (str, optional): ETag
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).outlook.master_categories.by_outlook_category_id(outlookCategory_id).delete(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_outlook_get_master_categories(
        self,
        user_id: str,
        outlookCategory_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
    ) -> OutlookCalendarContactsResponse:
        """Get masterCategories from users.
        Outlook operation: GET /users/{user-id}/outlook/masterCategories/{outlookCategory-id}
        Operation type: categories
        Args:
            user_id (str, required): Outlook user id identifier
            outlookCategory_id (str, required): Outlook outlookCategory 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).outlook.master_categories.by_outlook_category_id(outlookCategory_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_outlook_update_master_categories(
        self,
        user_id: str,
        outlookCategory_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
    ) -> OutlookCalendarContactsResponse:
        """Update the navigation property masterCategories in users.
        Outlook operation: PATCH /users/{user-id}/outlook/masterCategories/{outlookCategory-id}
        Operation type: categories
        Args:
            user_id (str, required): Outlook user id identifier
            outlookCategory_id (str, required): Outlook outlookCategory id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by content
            top (optional): Limit number of results returned
            skip (optional): Skip number of results for pagination
            request_body (optional): Request body data for Outlook operations
            headers (optional): Additional headers for the request
            **kwargs: Additional query parameters
        Returns:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).outlook.master_categories.by_outlook_category_id(outlookCategory_id).patch(body=request_body, request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    # ========== PEOPLE OPERATIONS (3 methods) ==========

    async def me_get_people(
        self,
        person_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
    ) -> OutlookCalendarContactsResponse:
        """Get people from me.
        Outlook operation: GET /me/people/{person-id}
        Operation type: people
        Args:
            person_id (str, required): Outlook person 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.people.by_person_id(person_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_list_people(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get people from users.
        Outlook operation: GET /users/{user-id}/people
        Operation type: people
        Args:
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).people.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_get_people(
        self,
        user_id: str,
        person_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
    ) -> OutlookCalendarContactsResponse:
        """Get people from users.
        Outlook operation: GET /users/{user-id}/people/{person-id}
        Operation type: people
        Args:
            user_id (str, required): Outlook user id identifier
            person_id (str, required): Outlook person 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).people.by_person_id(person_id).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    # ========== GENERAL OPERATIONS (8 methods) ==========

    async def me_get_outlook(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get outlook from me.
        Outlook operation: GET /me/outlook
        Operation type: general
        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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.outlook.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_outlook_supported_languages(
        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,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        """Invoke function supportedLanguages.
        Outlook operation: GET /me/outlook/supportedLanguages()
        Operation type: general
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.outlook.supported_languages().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_outlook_supported_time_zones_5c4f(
        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,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        """Invoke function supportedTimeZones.
        Outlook operation: GET /me/outlook/supportedTimeZones()
        Operation type: general
        Args:
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.outlook.supported_time_zones().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_outlook_supported_time_zones_0d20(
        self,
        TimeZoneStandard: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function supportedTimeZones.
        Outlook operation: GET /me/outlook/supportedTimeZones(TimeZoneStandard='{TimeZoneStandard}')
        Operation type: general
        Args:
            TimeZoneStandard (str, required): Outlook path parameter: TimeZoneStandard
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.me.outlook.supported_time_zones(_time_zone_standard='{_time_zone_standard}').get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_get_outlook(
        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
    ) -> OutlookCalendarContactsResponse:
        """Get outlook from users.
        Outlook operation: GET /users/{user-id}/outlook
        Operation type: general
        Args:
            user_id (str, required): Outlook 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., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).outlook.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_outlook_supported_languages(
        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,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        """Invoke function supportedLanguages.
        Outlook operation: GET /users/{user-id}/outlook/supportedLanguages()
        Operation type: general
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).outlook.supported_languages().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_outlook_supported_time_zones_5c4f(
        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,
        headers: Optional[Dict[str, str]] = None,
        **kwargs
    ) -> OutlookCalendarContactsResponse:
        """Invoke function supportedTimeZones.
        Outlook operation: GET /users/{user-id}/outlook/supportedTimeZones()
        Operation type: general
        Args:
            user_id (str, required): Outlook user id identifier
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).outlook.supported_time_zones().get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def users_user_outlook_supported_time_zones_0d20(
        self,
        user_id: str,
        TimeZoneStandard: 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
    ) -> OutlookCalendarContactsResponse:
        """Invoke function supportedTimeZones.
        Outlook operation: GET /users/{user-id}/outlook/supportedTimeZones(TimeZoneStandard='{TimeZoneStandard}')
        Operation type: general
        Args:
            user_id (str, required): Outlook user id identifier
            TimeZoneStandard (str, required): Outlook path parameter: TimeZoneStandard
            select (optional): Select specific properties to return
            expand (optional): Expand related entities (e.g., attachments, calendar)
            filter (optional): Filter the results using OData syntax
            orderby (optional): Order the results by specified properties
            search (optional): Search for messages, events, or contacts by 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:
            OutlookCalendarContactsResponse: Outlook response wrapper with success/data/error
        """
        # Build query parameters including OData for Outlook
        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 search:
                query_params.search = search
            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 Outlook
            if search:
                if not config.headers:
                    config.headers = {}
                config.headers['ConsistencyLevel'] = 'eventual'

            response = await self.client.users.by_user_id(user_id).outlook.supported_time_zones(_time_zone_standard='{_time_zone_standard}').get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    # ------------------------------------------------------------------
    # Online Meetings & Transcripts
    # ------------------------------------------------------------------

    async def me_list_online_meetings(
        self,
        filter: Optional[str] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs,
    ) -> OutlookCalendarContactsResponse:
        """List online meetings for the signed-in user.
        Outlook operation: GET /me/onlineMeetings

        NOTE: This endpoint only supports $filter (by JoinWebUrl).  $select,
        $expand, $top, $skip, $orderby, and $search are NOT allowed by the API.
        """
        try:
            from msgraph.generated.users.item.online_meetings.online_meetings_request_builder import (
                OnlineMeetingsRequestBuilder,
            )

            query_params = OnlineMeetingsRequestBuilder.OnlineMeetingsRequestBuilderGetQueryParameters()
            if filter:
                query_params.filter = filter

            config = RequestConfiguration(query_parameters=query_params)
            if headers:
                config.headers = headers

            response = await self.client.me.online_meetings.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_get_online_meeting(
        self,
        onlineMeeting_id: str,
        select: Optional[List[str]] = None,
        expand: Optional[List[str]] = None,
        headers: Optional[Dict[str, str]] = None,
        **kwargs,
    ) -> OutlookCalendarContactsResponse:
        """Get a specific online meeting by ID.
        Outlook operation: GET /me/onlineMeetings/{onlineMeeting-id}
        """
        try:
            config = RequestConfiguration()
            if select or expand:
                from msgraph.generated.users.item.online_meetings.item.online_meeting_item_request_builder import (
                    OnlineMeetingItemRequestBuilder,
                )
                query_params = OnlineMeetingItemRequestBuilder.OnlineMeetingItemRequestBuilderGetQueryParameters()
                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 = RequestConfiguration(query_parameters=query_params)
            if headers:
                config.headers = headers

            response = await self.client.me.online_meetings.by_online_meeting_id(
                onlineMeeting_id
            ).get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_list_online_meeting_transcripts(
        self,
        onlineMeeting_id: str,
        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,
        **kwargs,
    ) -> OutlookCalendarContactsResponse:
        """List transcripts for an online meeting.
        Outlook operation: GET /me/onlineMeetings/{onlineMeeting-id}/transcripts
        """
        try:
            from msgraph.generated.users.item.online_meetings.item.transcripts.transcripts_request_builder import (
                TranscriptsRequestBuilder,
            )

            query_params = TranscriptsRequestBuilder.TranscriptsRequestBuilderGetQueryParameters()
            if select:
                query_params.select = select if 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:
                config.headers = headers

            response = await self.client.me.online_meetings.by_online_meeting_id(
                onlineMeeting_id
            ).transcripts.get(request_configuration=config)
            return self._handle_outlook_response(response)
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_get_online_meeting_transcript_content(
        self,
        onlineMeeting_id: str,
        callTranscript_id: str,
        headers: Optional[Dict[str, str]] = None,
        **kwargs,
    ) -> OutlookCalendarContactsResponse:
        """Get the VTT content of a specific transcript.
        Outlook operation: GET /me/onlineMeetings/{id}/transcripts/{id}/content
        The Graph SDK returns bytes (VTT by default).
        """
        try:
            config = RequestConfiguration()
            if headers:
                config.headers = headers

            content_bytes = await self.client.me.online_meetings.by_online_meeting_id(
                onlineMeeting_id
            ).transcripts.by_call_transcript_id(
                callTranscript_id
            ).content.get(request_configuration=config)

            if content_bytes is None:
                return OutlookCalendarContactsResponse(
                    success=False,
                    error="Transcript content is empty",
                )

            text = content_bytes.decode("utf-8") if isinstance(content_bytes, bytes) else str(content_bytes)
            return OutlookCalendarContactsResponse(
                success=True,
                data={"content": text, "format": "vtt"},
            )
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_get_online_meeting_transcript_metadata(
        self,
        onlineMeeting_id: str,
        callTranscript_id: str,
        headers: Optional[Dict[str, str]] = None,
        **kwargs,
    ) -> OutlookCalendarContactsResponse:
        """Get the metadata content (speaker diarization JSON) of a transcript.
        Outlook operation: GET /me/onlineMeetings/{id}/transcripts/{id}/metadataContent
        """
        try:
            config = RequestConfiguration()
            if headers:
                config.headers = headers

            content_bytes = await self.client.me.online_meetings.by_online_meeting_id(
                onlineMeeting_id
            ).transcripts.by_call_transcript_id(
                callTranscript_id
            ).metadata_content.get(request_configuration=config)

            if content_bytes is None:
                return OutlookCalendarContactsResponse(
                    success=False,
                    error="Transcript metadata content is empty",
                )

            text = content_bytes.decode("utf-8") if isinstance(content_bytes, bytes) else str(content_bytes)
            return OutlookCalendarContactsResponse(
                success=True,
                data={"content": text, "format": "metadata_json"},
            )
        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_list_series_master_events(
        self,
        top: Optional[int] = None,
        skip: Optional[int] = None,
        timezone: str = "UTC",
        headers: Optional[Dict[str, str]] = None,
    ) -> OutlookCalendarContactsResponse:
        """List all seriesMaster (recurring) events.
        Outlook operation: GET /me/events?$filter=type eq 'seriesMaster'
        """
        try:
            from msgraph.generated.users.item.events.events_request_builder import (
                EventsRequestBuilder,
            )

            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters(
                filter="type eq 'seriesMaster'",
            )
            if top is not None:
                query_params.top = top
            if skip is not None:
                query_params.skip = skip

            config = EventsRequestBuilder.EventsRequestBuilderGetRequestConfiguration(
                query_parameters=query_params,
            )
            config.headers.try_add("Prefer", f'outlook.timezone="{timezone}"')

            if headers:
                for key, value in headers.items():
                    config.headers.try_add(key, value)

            response = await self.client.me.events.get(request_configuration=config)
            return self._handle_outlook_response(response)

        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_search_events_in_range(
        self,
        keyword: str,
        start_datetime: str,
        end_datetime: str,
        timezone: str = "UTC",
        top: Optional[int] = None,
        headers: Optional[Dict[str, str]] = None,
    ) -> OutlookCalendarContactsResponse:
        """Search events by partial subject match within a time range.
        Outlook operation: GET /me/events?$filter=contains(subject,'{keyword}')
                        and start/dateTime ge '{start}' and end/dateTime le '{end}'
        """
        try:
            from msgraph.generated.users.item.events.events_request_builder import (
                EventsRequestBuilder,
            )

            safe_keyword = keyword.strip().replace("'", "''")

            odata_filter = (
                f"contains(subject, '{safe_keyword}')"
                f" and start/dateTime ge '{start_datetime}'"
                f" and end/dateTime le '{end_datetime}'"
            )

            query_params = EventsRequestBuilder.EventsRequestBuilderGetQueryParameters(
                filter=odata_filter,
                orderby=["start/dateTime"],
            )
            if top is not None:
                query_params.top = top

            config = EventsRequestBuilder.EventsRequestBuilderGetRequestConfiguration(
                query_parameters=query_params,
            )
            config.headers.try_add("Prefer", f'outlook.timezone="{timezone}"')

            if headers:
                for key, value in headers.items():
                    config.headers.try_add(key, value)

            response = await self.client.me.events.get(request_configuration=config)
            return self._handle_outlook_response(response)

        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_get_schedule(
        self,
        start_datetime: str,
        end_datetime: str,
        timezone: str = "UTC",
        availability_view_interval: int = 30,
        headers: Optional[Dict[str, str]] = None,
    ) -> OutlookCalendarContactsResponse:
        """Get schedule (busy/free) for the signed-in user.
        Outlook operation: POST /me/calendar/getSchedule
        """
        try:
            from msgraph.generated.models.date_time_time_zone import DateTimeTimeZone
            from msgraph.generated.users.item.calendar.get_schedule.get_schedule_post_request_body import (
                GetSchedulePostRequestBody,
            )

            # Fetch the signed-in user's email to pass as the schedule request target
            me_resp = await self.client.me.get()
            user_email = getattr(me_resp, 'mail', None) or getattr(me_resp, 'user_principal_name', None)
            if not user_email:
                return OutlookCalendarContactsResponse(
                    success=False,
                    error="Could not resolve signed-in user email for getSchedule.",
                )

            start_obj = DateTimeTimeZone()
            start_obj.date_time = start_datetime
            start_obj.time_zone = timezone

            end_obj = DateTimeTimeZone()
            end_obj.date_time = end_datetime
            end_obj.time_zone = timezone

            body = GetSchedulePostRequestBody()
            body.schedules = [user_email]
            body.start_time = start_obj
            body.end_time = end_obj
            body.availability_view_interval = 15  # granularity in minutes

            config = RequestConfiguration()
            if headers:
                for key, value in headers.items():
                    config.headers.try_add(key, value)

            response = await self.client.me.calendar.get_schedule.post(
                body=body,
                request_configuration=config,
            )
            return self._handle_outlook_response(response)

        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )

    async def me_list_event_occurrences(
        self,
        event_id: str,
        end_date: str,
        start_date: Optional[str] = None,
        timezone: str = "UTC",
        headers: Optional[Dict[str, str]] = None,
    ) -> OutlookCalendarContactsResponse:
        """List occurrences of a recurring event within a date window.
        Outlook operation: GET /me/events/{id}/instances?startDateTime=...&endDateTime=...
        """
        try:
            query_params = InstancesRequestBuilder.InstancesRequestBuilderGetQueryParameters(
                start_date_time=f"{start_date or date.today().isoformat()}T00:00:00",
                end_date_time=f"{end_date}T23:59:59",
            )
            query_params.top = 100

            config = InstancesRequestBuilder.InstancesRequestBuilderGetRequestConfiguration(
                query_parameters=query_params,
            )
            config.headers.try_add("Prefer", f'outlook.timezone="{timezone}"')
            if headers:
                for key, value in headers.items():
                    config.headers.try_add(key, value)

            response = await self.client.me.events.by_event_id(event_id).instances.get(
                request_configuration=config
            )

            occurrences = []
            for item in (getattr(response, "value", None) or []):
                item_dict = {
                    attr: val
                    for attr in ("id", "subject", "type", "series_master_id")
                    if (val := getattr(item, attr, None)) is not None
                }

                if not item_dict.get("id"):
                    continue

                for key, obj_attr in (("start", "start"), ("end", "end")):
                    obj = getattr(item, obj_attr, None)
                    if obj:
                        item_dict[key] = {
                            "dateTime": getattr(obj, "date_time", None),
                            "timeZone": getattr(obj, "time_zone", None),
                        }

                occurrences.append(item_dict)

            return OutlookCalendarContactsResponse(success=True, data={"value": occurrences})

        except Exception as e:
            return OutlookCalendarContactsResponse(
                success=False,
                error=f"Outlook API call failed: {str(e)}",
            )