"""
Zoom REST API DataSource - Auto-generated API wrapper

Generated from Zoom OpenAPI specifications.
Uses HTTP client for direct REST API interactions.
"""

from __future__ import annotations

from typing import Any

from app.sources.client.http.http_request import HTTPRequest
from app.sources.client.zoom.zoom import ZoomClient, ZoomResponse

# HTTP status code constant
HTTP_ERROR_THRESHOLD = 400


class ZoomDataSource:
    """Zoom REST API DataSource

    Auto-generated async wrapper methods for Zoom REST API operations
    covering Users, Meetings, Phone, Team Chat, Calendar, Rooms,
    Accounts, Clips, Whiteboard, Mail, and more.

    All methods return ZoomResponse objects.
    """

    def __init__(self, client: ZoomClient) -> None:
        """Initialize with ZoomClient.

        Args:
            client: ZoomClient instance with configured authentication
        """
        self._client = client
        self.http = client.get_client()
        try:
            self.base_url = self.http.get_base_url().rstrip('/')
        except AttributeError as exc:
            raise ValueError('HTTP client does not have get_base_url method') from exc

    def get_data_source(self) -> 'ZoomDataSource':
        """Return the data source instance."""
        return self

    def get_client(self) -> ZoomClient:
        """Return the underlying ZoomClient."""
        return self._client

    async def get_ai_cconversationarchives(
        self,
        userId: str
    ) -> ZoomResponse:
        """Get AI Companion conversation archives

        HTTP GET /aic/users/{userId}/conversation_archive

        Args:
            userId: The user's user ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/aic/users/{userId}/conversation_archive".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_ai_cconversationarchives" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_ai_cconversationarchives")

    async def get_account_lock_settings(
        self,
        accountId: str,
        option: str | None = None,
        custom_query_fields: str | None = None
    ) -> ZoomResponse:
        """Get locked settings

        HTTP GET /accounts/{accountId}/lock_settings

        Args:
            accountId: Path parameter
            option: Optional query parameters:  * `meeting_security` &mdash; Use this query parameter to view the meeting security settings
            custom_query_fields: Provide the name of the field by which you would like to filter the response. For example, if you provide &quot;host_vid

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if option is not None:
            query_params['option'] = option
        if custom_query_fields is not None:
            query_params['custom_query_fields'] = custom_query_fields

        url = self.base_url + "/accounts/{accountId}/lock_settings".format(accountId=accountId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_account_lock_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_account_lock_settings")

    async def update_locked_settings(
        self,
        accountId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update locked settings

        HTTP PATCH /accounts/{accountId}/lock_settings

        Args:
            accountId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/accounts/{accountId}/lock_settings".format(accountId=accountId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_locked_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_locked_settings")

    async def account_managed_domain(
        self,
        accountId: str
    ) -> ZoomResponse:
        """Get account's managed domains

        HTTP GET /accounts/{accountId}/managed_domains

        Args:
            accountId: The account's ID. For master accounts, pass the `me` value for this parameter.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/accounts/{accountId}/managed_domains".format(accountId=accountId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed account_managed_domain" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute account_managed_domain")

    async def update_the_account_owner(
        self,
        accountId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update the account owner

        HTTP PUT /accounts/{accountId}/owner

        Args:
            accountId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/accounts/{accountId}/owner".format(accountId=accountId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_the_account_owner" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_the_account_owner")

    async def account_settings(
        self,
        accountId: str,
        option: str | None = None,
        custom_query_fields: str | None = None
    ) -> ZoomResponse:
        """Get account settings

        HTTP GET /accounts/{accountId}/settings

        Args:
            accountId: Path parameter
            option: Optional query parameters.  * `meeting_authentication` - View the [meeting authentication settings](https://support.zoom
            custom_query_fields: The name of the field to use to filter the response. For example, if you provide the `host_video` value for this field,

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if option is not None:
            query_params['option'] = option
        if custom_query_fields is not None:
            query_params['custom_query_fields'] = custom_query_fields

        url = self.base_url + "/accounts/{accountId}/settings".format(accountId=accountId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed account_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute account_settings")

    async def account_settings_update(
        self,
        accountId: str,
        body: dict[str, Any],
        option: str | None = None
    ) -> ZoomResponse:
        """Update account settings

        HTTP PATCH /accounts/{accountId}/settings

        Args:
            accountId: Path parameter
            body: Request body payload
            option: Optional query parameters.  * `meeting_authentication` - View the [meeting authentication settings](https://support.zoom

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if option is not None:
            query_params['option'] = option

        url = self.base_url + "/accounts/{accountId}/settings".format(accountId=accountId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed account_settings_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute account_settings_update")

    async def account_settings_registration(
        self,
        accountId: str,
        type_: str | None = None
    ) -> ZoomResponse:
        """Get an account's webinar registration settings

        HTTP GET /accounts/{accountId}/settings/registration

        Args:
            accountId: The account's ID. For master accounts, pass the `me` value for this parameter.
            type_: The registration's type. * `webinar` &mdash; webinar.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_

        url = self.base_url + "/accounts/{accountId}/settings/registration".format(accountId=accountId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed account_settings_registration" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute account_settings_registration")

    async def account_settings_registration_update(
        self,
        accountId: str,
        body: dict[str, Any],
        type_: str | None = None
    ) -> ZoomResponse:
        """Update an account's webinar registration settings

        HTTP PATCH /accounts/{accountId}/settings/registration

        Args:
            accountId: The account's ID. For master accounts, pass the `me` value for this parameter.
            body: Request body payload
            type_: The registration's type. * `webinar` &mdash; webinar.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_

        url = self.base_url + "/accounts/{accountId}/settings/registration".format(accountId=accountId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed account_settings_registration_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute account_settings_registration_update")

    async def upload_vb(
        self,
        accountId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Upload virtual background files

        HTTP POST /accounts/{accountId}/settings/virtual_backgrounds

        Args:
            accountId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/accounts/{accountId}/settings/virtual_backgrounds".format(accountId=accountId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed upload_vb" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute upload_vb")

    async def del_vb(
        self,
        accountId: str,
        file_ids: str | None = None
    ) -> ZoomResponse:
        """Delete virtual background files

        HTTP DELETE /accounts/{accountId}/settings/virtual_backgrounds

        Args:
            accountId: Path parameter
            file_ids: A comma-separated list of file IDs to delete.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if file_ids is not None:
            query_params['file_ids'] = file_ids

        url = self.base_url + "/accounts/{accountId}/settings/virtual_backgrounds".format(accountId=accountId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed del_vb" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute del_vb")

    async def account_trusted_domain(
        self,
        accountId: str
    ) -> ZoomResponse:
        """Get account's trusted domains

        HTTP GET /accounts/{accountId}/trusted_domains

        Args:
            accountId: The account's ID. For master accounts, pass the `me` value for this parameter.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/accounts/{accountId}/trusted_domains".format(accountId=accountId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed account_trusted_domain" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute account_trusted_domain")

    async def dashboard_chat(
        self,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get chat metrics

        HTTP GET /metrics/chat

        Args:
            from_: Start date in 'yyyy-mm-dd' format. The date range defined by the &quot;from&quot; and &quot;to&quot; parameters should o
            to: End date.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/metrics/chat"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_chat" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_chat")

    async def dashboard_client_feedback(
        self,
        from_: str | None = None,
        to: str | None = None
    ) -> ZoomResponse:
        """List Zoom meetings client feedback

        HTTP GET /metrics/client/feedback

        Args:
            from_: Start date in 'yyyy-mm-dd' format. The date range defined by the &quot;from&quot; and &quot;to&quot; parameters should o
            to: End date.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to

        url = self.base_url + "/metrics/client/feedback"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_client_feedback" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_client_feedback")

    async def dashboard_client_feedback_detail(
        self,
        feedbackId: str,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get zoom meetings client feedback

        HTTP GET /metrics/client/feedback/{feedbackId}

        Args:
            feedbackId: Feedback Detail Id
            from_: Query parameter
            to: Query parameter
            page_size: Query parameter
            next_page_token: Query parameter

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/metrics/client/feedback/{feedbackId}".format(feedbackId=feedbackId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_client_feedback_detail" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_client_feedback_detail")

    async def list_meeting_satisfaction(
        self,
        from_: str | None = None,
        to: str | None = None
    ) -> ZoomResponse:
        """List client meeting satisfaction

        HTTP GET /metrics/client/satisfaction

        Args:
            from_: The start date for the query in &ldquo;yyyy-mm-dd&rdquo; format.
            to: The end date for the query in &ldquo;yyyy-mm-dd&rdquo; format.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to

        url = self.base_url + "/metrics/client/satisfaction"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_meeting_satisfaction" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_meeting_satisfaction")

    async def get_client_versions(
        self
    ) -> ZoomResponse:
        """List the client versions

        HTTP GET /metrics/client_versions

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/metrics/client_versions"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_client_versions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_client_versions")

    async def dashboard_crc(
        self,
        from_: str | None = None,
        to: str | None = None
    ) -> ZoomResponse:
        """Get CRC port usage

        HTTP GET /metrics/crc

        Args:
            from_: Start date in 'yyyy-mm-dd' format. The date range defined by the &quot;from&quot; and &quot;to&quot; parameters should o
            to: End date.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to

        url = self.base_url + "/metrics/crc"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_crc" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_crc")

    async def dashboard_issue_zoom_room(
        self,
        from_: str | None = None,
        to: str | None = None
    ) -> ZoomResponse:
        """Get top 25 Zoom Rooms with issues

        HTTP GET /metrics/issues/zoomrooms

        Args:
            from_: Start date in 'yyyy-mm-dd' format. The date range defined by the &quot;from&quot; and &quot;to&quot; parameters should o
            to: End date.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to

        url = self.base_url + "/metrics/issues/zoomrooms"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_issue_zoom_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_issue_zoom_room")

    async def dashboard_issue_detail_zoom_room(
        self,
        zoomroomId: str,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get issues of Zoom Rooms

        HTTP GET /metrics/issues/zoomrooms/{zoomroomId}

        Args:
            zoomroomId: The Zoom room ID.
            from_: Start date in 'yyyy-mm-dd' format. The date range defined by the &quot;from&quot; and &quot;to&quot; parameters should o
            to: End date.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/metrics/issues/zoomrooms/{zoomroomId}".format(zoomroomId=zoomroomId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_issue_detail_zoom_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_issue_detail_zoom_room")

    async def dashboard_meetings(
        self,
        *,
        type_: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        group_id: str | None = None,
        group_include_participant: bool | None = None,
        include_fields: str | None = None,
        query_date_type: str | None = None
    ) -> ZoomResponse:
        """List meetings

        HTTP GET /metrics/meetings

        Args:
            type_: A value to get the response for the corresponding meeting type.      `past` - Meetings that already occurred in the spec
            from_: The start date in 'yyyy-MM-dd HH:mm:ss' or 'yyyy-MM-dd' format. The date range defined by the `from` and `to` parameters
            to: The end date 'yyyy-MM-dd HH:mm:ss' or 'yyyy-MM-dd' format.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            group_id: The group ID. To get a group ID, use the [**List groups**](https://developers.zoom.us/docs/api/rest/reference/scim-api/m
            group_include_participant: Whether the response will contain meetings where the participant is a member of the queried group ID.
            include_fields: Sets the value of this field to `tracking_fields` if you want to include tracking fields of each meeting in the response
            query_date_type: The type of date to query. This field is only supported when `type` is `past`.  * `start_time` - Query by call start tim

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if group_id is not None:
            query_params['group_id'] = group_id
        if group_include_participant is not None:
            query_params['group_include_participant'] = str(group_include_participant).lower()
        if include_fields is not None:
            query_params['include_fields'] = include_fields
        if query_date_type is not None:
            query_params['query_date_type'] = query_date_type

        url = self.base_url + "/metrics/meetings"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_meetings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_meetings")

    async def dashboard_meeting_detail(
        self,
        meetingId: str,
        type_: str | None = None
    ) -> ZoomResponse:
        """Get meeting details

        HTTP GET /metrics/meetings/{meetingId}

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API will return a response for the
            type_: The type of meeting to query.  * `past` &mdash; All past meetings.  * `pastOne` &mdash; All past one-user meetings.  * `

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_

        url = self.base_url + "/metrics/meetings/{meetingId}".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_meeting_detail" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_meeting_detail")

    async def dashboard_meeting_participants(
        self,
        meetingId: str,
        type_: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        include_fields: str | None = None
    ) -> ZoomResponse:
        """List meeting participants

        HTTP GET /metrics/meetings/{meetingId}/participants

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API returns a response for the lat
            type_: The type of meeting to query.  * `past` - All past meetings.  * `pastOne` - All past one-user meetings.  * `live` - All
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through a large set of results. A next page token returns whenever the set of availa
            include_fields: This field provides `registrant_id` as the value for this field if you would like to see the registrant ID attribute in

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if include_fields is not None:
            query_params['include_fields'] = include_fields

        url = self.base_url + "/metrics/meetings/{meetingId}/participants".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_meeting_participants" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_meeting_participants")

    async def dashboard_meeting_participants_qos(
        self,
        meetingId: str,
        type_: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List meeting participants QoS

        HTTP GET /metrics/meetings/{meetingId}/participants/qos

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API will return a response for the
            type_: The type of meeting to query.  * `past` - All past meetings.  * `live` - All live meetings.   This value defaults to `li
            page_size: The number of items returned per page.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/metrics/meetings/{meetingId}/participants/qos".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_meeting_participants_qos" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_meeting_participants_qos")

    async def participant_feedback(
        self,
        meetingId: str,
        type_: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """Get post meeting feedback

        HTTP GET /metrics/meetings/{meetingId}/participants/satisfaction

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API will return a response for the
            type_: Specify a value to get the response for the corresponding meeting type. The value of this field can be one of the follow
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            page_size: The number of records returned within a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/metrics/meetings/{meetingId}/participants/satisfaction".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed participant_feedback" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute participant_feedback")

    async def dashboard_meeting_participant_share(
        self,
        meetingId: str,
        type_: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get meeting sharing/recording details

        HTTP GET /metrics/meetings/{meetingId}/participants/sharing

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API will return a response for the
            type_: The type of meeting to query:  * `past` &mdash; All past meetings.  * `live` - All live meetings.   This value defaults
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/metrics/meetings/{meetingId}/participants/sharing".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_meeting_participant_share" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_meeting_participant_share")

    async def dashboard_meeting_participant_qos(
        self,
        meetingId: str,
        participantId: str,
        type_: str | None = None
    ) -> ZoomResponse:
        """Get meeting participant QoS

        HTTP GET /metrics/meetings/{meetingId}/participants/{participantId}/qos

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API will return a response for the
            participantId: The participant's ID.
            type_: The type of meeting to query.  * `past` - All past meetings.  * `live` - All live meetings.   This value defaults to `li

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_

        url = self.base_url + "/metrics/meetings/{meetingId}/participants/{participantId}/qos".format(meetingId=meetingId, participantId=participantId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_meeting_participant_qos" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_meeting_participant_qos")

    async def dashboard_quality(
        self,
        from_: str | None = None,
        to: str | None = None,
        type_: str | None = None
    ) -> ZoomResponse:
        """Get meeting quality scores

        HTTP GET /metrics/quality

        Args:
            from_: Start date in 'yyyy-mm-dd' format. The date range defined by the &quot;from&quot; and &quot;to&quot; parameters should o
            to: End date.
            type_: The type of meeting quality score to query:  * `meeting` &mdash; Query by meetings.  * `participants` &mdash; Query by m

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if type_ is not None:
            query_params['type'] = type_

        url = self.base_url + "/metrics/quality"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_quality" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_quality")

    async def dashboard_webinars(
        self,
        *,
        type_: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        group_id: str | None = None,
        group_include_participant: bool | None = None,
        query_date_type: str | None = None
    ) -> ZoomResponse:
        """List webinars

        HTTP GET /metrics/webinars

        Args:
            type_: The type of webinar to query.  * `past` - All past webinars.  * `live` - All live webinars.   This value defaults to `li
            from_: The start date in 'yyyy-MM-dd HH:mm:ss' or 'yyyy-MM-dd'format. The date range defined by the `from` and `to` parameters
            to: The end date 'yyyy-MM-dd HH:mm:ss' or 'yyyy-MM-dd' format.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            group_id: The group ID. To get a group ID, use the [**List groups**](https://developers.zoom.us/docs/api/rest/reference/scim-api/m
            group_include_participant: Whether the response will contain webinars where the participant is a member of the queried group ID.
            query_date_type: The type of date to query. This field is only supported when `type` is `past`.  * `start_time` - Query by call start tim

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if group_id is not None:
            query_params['group_id'] = group_id
        if group_include_participant is not None:
            query_params['group_include_participant'] = str(group_include_participant).lower()
        if query_date_type is not None:
            query_params['query_date_type'] = query_date_type

        url = self.base_url + "/metrics/webinars"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_webinars" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_webinars")

    async def dashboard_webinar_detail(
        self,
        webinarId: str,
        type_: str | None = None
    ) -> ZoomResponse:
        """Get webinar details

        HTTP GET /metrics/webinars/{webinarId}

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API will return a response for the
            type_: The type of webinar to query:  * `past` &mdash; All past webinars.  * `live` - All live webinars.   This value defaults

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_

        url = self.base_url + "/metrics/webinars/{webinarId}".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_webinar_detail" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_webinar_detail")

    async def dashboard_webinar_participants(
        self,
        webinarId: str,
        type_: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        include_fields: str | None = None
    ) -> ZoomResponse:
        """Get webinar participants

        HTTP GET /metrics/webinars/{webinarId}/participants

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API returns a response for the lat
            type_: The type of webinar to query.  * `past` - All past webinars.  * `live` - All live webinars.   This value defaults to `li
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            include_fields: The additional fields to include in the query.  * `registrant_id` - Includes the webinar registrant's ID. The registrant

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if include_fields is not None:
            query_params['include_fields'] = include_fields

        url = self.base_url + "/metrics/webinars/{webinarId}/participants".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_webinar_participants" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_webinar_participants")

    async def dashboard_webinar_participants_qos(
        self,
        webinarId: str,
        type_: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List webinar participant QoS

        HTTP GET /metrics/webinars/{webinarId}/participants/qos

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API will return a response for the
            type_: The type of webinar to query.  * `past` - All past webinars.  * `live` - All live webinars.   This value defaults to `li
            page_size: The number of items returned per page.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/metrics/webinars/{webinarId}/participants/qos".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_webinar_participants_qos" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_webinar_participants_qos")

    async def participant_webinar_feedback(
        self,
        webinarId: str,
        type_: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get post webinar feedback

        HTTP GET /metrics/webinars/{webinarId}/participants/satisfaction

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API will return a response for the
            type_: Specify a value to get the response for the corresponding meeting type. The value of this field can be one of the follow
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/metrics/webinars/{webinarId}/participants/satisfaction".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed participant_webinar_feedback" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute participant_webinar_feedback")

    async def dashboard_webinar_participant_share(
        self,
        webinarId: str,
        type_: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get webinar sharing/recording details

        HTTP GET /metrics/webinars/{webinarId}/participants/sharing

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API will return a response for the
            type_: The type of webinar to query:  * `past` &mdash; All past webinars.  * `live` - All live webinars.   This value defaults
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/metrics/webinars/{webinarId}/participants/sharing".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_webinar_participant_share" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_webinar_participant_share")

    async def dashboard_webinar_participant_qos(
        self,
        webinarId: str,
        participantId: str,
        type_: str | None = None
    ) -> ZoomResponse:
        """Get webinar participant QoS

        HTTP GET /metrics/webinars/{webinarId}/participants/{participantId}/qos

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API will return a response for the
            participantId: The participant's ID.
            type_: The type of webinar to query.  * `past` - All past webinars.  * `live` - All live webinars.   This value defaults to `li

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_

        url = self.base_url + "/metrics/webinars/{webinarId}/participants/{participantId}/qos".format(webinarId=webinarId, participantId=participantId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_webinar_participant_qos" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_webinar_participant_qos")

    async def dashboard_zoom_rooms(
        self,
        page_size: int | None = None,
        page_number: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List Zoom Rooms

        HTTP GET /metrics/zoomrooms

        Args:
            page_size: The number of records returned within a single API call.
            page_number: The page number of the current page in the returned records.
            next_page_token: The next page token is used to paginate through large result sets. A next page token will be returned whenever the set o

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if page_number is not None:
            query_params['page_number'] = str(page_number)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/metrics/zoomrooms"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_zoom_rooms" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_zoom_rooms")

    async def dashboard_zoom_room_issue(
        self,
        from_: str | None = None,
        to: str | None = None
    ) -> ZoomResponse:
        """Get top 25 issues of Zoom Rooms

        HTTP GET /metrics/zoomrooms/issues

        Args:
            from_: Start date in 'yyyy-mm-dd' format. The date range defined by the &quot;from&quot; and &quot;to&quot; parameters should o
            to: End date.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to

        url = self.base_url + "/metrics/zoomrooms/issues"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_zoom_room_issue" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_zoom_room_issue")

    async def dashboard_zoom_room(
        self,
        zoomroomId: str,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get Zoom Rooms details

        HTTP GET /metrics/zoomrooms/{zoomroomId}

        Args:
            zoomroomId: The Zoom room ID.
            from_: Start date in 'yyyy-mm-dd' format. The date range defined by the &quot;from&quot; and &quot;to&quot; parameters should o
            to: End date.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/metrics/zoomrooms/{zoomroomId}".format(zoomroomId=zoomroomId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_zoom_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_zoom_room")

    async def downloadfilesfrom_data_request(
        self,
        fileId: str
    ) -> ZoomResponse:
        """Get download link for data access request file

        HTTP GET /data_requests/files/{fileId}/url

        Args:
            fileId: The file id (retrieved from Get Downloadable Files for Data Request api)

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/data_requests/files/{fileId}/url".format(fileId=fileId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed downloadfilesfrom_data_request" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute downloadfilesfrom_data_request")

    async def get_data_requests_history(
        self,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List data request history

        HTTP GET /data_requests/requests

        Args:
            next_page_token: Token retrieved from previous API call, used for next page in pagination. Expires after 15 minutes.
            page_size: Number of records to retrieve. Maximum set at 10, if invalid (<= 0), will automatically be set as 10.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/data_requests/requests"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_data_requests_history" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_data_requests_history")

    async def create_data_access_request(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create data  (export/deletion) request

        HTTP POST /data_requests/requests

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/data_requests/requests"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_data_access_request" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_data_access_request")

    async def get_downloadable_filesfor_data_request(
        self,
        requestId: str,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List downloadable files for export data request

        HTTP GET /data_requests/requests/{requestId}

        Args:
            requestId: ID of data export request
            next_page_token: Used in pagination to retrieve next page of results.
            page_size: Number of results to retrieve per page. Limit is set at 6.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/data_requests/requests/{requestId}".format(requestId=requestId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_downloadable_filesfor_data_request" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_downloadable_filesfor_data_request")

    async def cancel_data_request(
        self,
        requestId: str
    ) -> ZoomResponse:
        """Cancel data deletion request

        HTTP DELETE /data_requests/requests/{requestId}

        Args:
            requestId: ID of data request to cancel

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/data_requests/requests/{requestId}".format(requestId=requestId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed cancel_data_request" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute cancel_data_request")

    async def information_barriers_list(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List information Barrier policies

        HTTP GET /information_barriers/policies

        Args:
            page_size: Number of records to return per API call
            next_page_token: Token from previous API call that indicates to get the next page of results

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/information_barriers/policies"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed information_barriers_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute information_barriers_list")

    async def information_barriers_create(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create an Information Barrier policy

        HTTP POST /information_barriers/policies

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/information_barriers/policies"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed information_barriers_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute information_barriers_create")

    async def information_barriers_get(
        self,
        policyId: str
    ) -> ZoomResponse:
        """Get an Information Barrier policy by ID

        HTTP GET /information_barriers/policies/{policyId}

        Args:
            policyId: The Information Barrier policy's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/information_barriers/policies/{policyId}".format(policyId=policyId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed information_barriers_get" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute information_barriers_get")

    async def information_barriers_delete(
        self,
        policyId: str
    ) -> ZoomResponse:
        """Remove an Information Barrier policy

        HTTP DELETE /information_barriers/policies/{policyId}

        Args:
            policyId: The Information Barriers policy's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/information_barriers/policies/{policyId}".format(policyId=policyId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed information_barriers_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute information_barriers_delete")

    async def information_barriers_update(
        self,
        policyId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update an Information Barriers policy

        HTTP PATCH /information_barriers/policies/{policyId}

        Args:
            policyId: The Information Barriers policy's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/information_barriers/policies/{policyId}".format(policyId=policyId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed information_barriers_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute information_barriers_update")

    async def roles(
        self,
        type_: str | None = None
    ) -> ZoomResponse:
        """List roles

        HTTP GET /roles

        Args:
            type_: Specify a value to get the response for the corresponding role type.         `common` - common roles of Zoom.    `iq` -

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_

        url = self.base_url + "/roles"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed roles" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute roles")

    async def create_role(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a role

        HTTP POST /roles

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/roles"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_role" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_role")

    async def get_role_information(
        self,
        roleId: str
    ) -> ZoomResponse:
        """Get role information

        HTTP GET /roles/{roleId}

        Args:
            roleId: The role ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/roles/{roleId}".format(roleId=roleId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_role_information" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_role_information")

    async def delete_role(
        self,
        roleId: str
    ) -> ZoomResponse:
        """Delete a role

        HTTP DELETE /roles/{roleId}

        Args:
            roleId: Path parameter

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/roles/{roleId}".format(roleId=roleId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_role" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_role")

    async def update_role(
        self,
        roleId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update role information

        HTTP PATCH /roles/{roleId}

        Args:
            roleId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/roles/{roleId}".format(roleId=roleId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_role" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_role")

    async def role_members(
        self,
        roleId: str,
        page_count: str | None = None,
        page_number: int | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List members in a role

        HTTP GET /roles/{roleId}/members

        Args:
            roleId: The role ID
            page_count: The number of pages returned for this request.
            page_number: **Deprecated.** We will no longer support this field in a future release. Instead, use the `next_page_token` for paginat
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            page_size: The number of records returned within a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_count is not None:
            query_params['page_count'] = page_count
        if page_number is not None:
            query_params['page_number'] = str(page_number)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/roles/{roleId}/members".format(roleId=roleId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed role_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute role_members")

    async def add_role_members(
        self,
        roleId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign a role

        HTTP POST /roles/{roleId}/members

        Args:
            roleId: The role ID
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/roles/{roleId}/members".format(roleId=roleId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_role_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_role_members")

    async def role_member_delete(
        self,
        roleId: str,
        memberId: str
    ) -> ZoomResponse:
        """Unassign a role

        HTTP DELETE /roles/{roleId}/members/{memberId}

        Args:
            roleId: The role ID
            memberId: Member's ID

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/roles/{roleId}/members/{memberId}".format(roleId=roleId, memberId=memberId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed role_member_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute role_member_delete")

    async def get_account_surveys(
        self,
        page_size: str | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get surveys

        HTTP GET /surveys

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through a large set of results. A next page token returns whenever the set of availa

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = page_size
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/surveys"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_account_surveys" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_account_surveys")

    async def get_survey_info(
        self,
        surveyId: str
    ) -> ZoomResponse:
        """Get survey info

        HTTP GET /surveys/{surveyId}

        Args:
            surveyId: The UUID of survey.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/surveys/{surveyId}".format(surveyId=surveyId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_survey_info" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_survey_info")

    async def get_survey_answers(
        self,
        surveyId: str,
        page_size: str | None = None,
        next_page_token: str | None = None,
        instance_id: str | None = None,
        submit_time_start: str | None = None,
        submit_time_end: str | None = None
    ) -> ZoomResponse:
        """Get survey answers

        HTTP GET /surveys/{surveyId}/answers

        Args:
            surveyId: The UUID of survey.
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. It returns whenever the set of available results exceeds t
            instance_id: **Optional** Returns the answers of the survey in the specified instance. This parameter needs double encode.
            submit_time_start: Start of submit time range (ISO 8601 format, e.g., 2025-09-22T10:00:00Z).
            submit_time_end: End of submit time range (ISO 8601 format, e.g., 2025-09-22T10:00:00Z).

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = page_size
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if instance_id is not None:
            query_params['instance_id'] = instance_id
        if submit_time_start is not None:
            query_params['submit_time_start'] = submit_time_start
        if submit_time_end is not None:
            query_params['submit_time_end'] = submit_time_end

        url = self.base_url + "/surveys/{surveyId}/answers".format(surveyId=surveyId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_survey_answers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_survey_answers")

    async def get_survey_instances_info(
        self,
        surveyId: str,
        page_size: str | None = None,
        next_page_token: str | None = None,
        instance_id: str | None = None
    ) -> ZoomResponse:
        """Get survey instances

        HTTP GET /surveys/{surveyId}/instances

        Args:
            surveyId: The UUID of survey.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            instance_id: **Optional**, return the survey information used in the specified instance. This parameter needs dobule encode.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = page_size
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if instance_id is not None:
            query_params['instance_id'] = instance_id

        url = self.base_url + "/surveys/{surveyId}/instances".format(surveyId=surveyId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_survey_instances_info" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_survey_instances_info")

    async def listacl(
        self,
        calId: str,
        *,
        maxResults: int | None = None,
        showDeleted: bool | None = None,
        pageToken: str | None = None
    ) -> ZoomResponse:
        """List ACL rules of specified calendar

        HTTP GET /calendars/{calId}/acl

        Args:
            calId: The calendar identifier. To retrieve calendar IDs call, the `calendarList.list` method.
            maxResults: The maximum number of entries returned on one result page.
            showDeleted: Whether to include deleted ACLs in the result.
            pageToken: The token that specifies which result page to return.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if maxResults is not None:
            query_params['maxResults'] = str(maxResults)
        if showDeleted is not None:
            query_params['showDeleted'] = str(showDeleted).lower()
        if pageToken is not None:
            query_params['pageToken'] = pageToken

        url = self.base_url + "/calendars/{calId}/acl".format(calId=calId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed listacl" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute listacl")

    async def insertacl(
        self,
        calId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a new ACL rule

        HTTP POST /calendars/{calId}/acl

        Args:
            calId: The calendar identifier. To retrieve calendar IDs call, the `calendarList.list` method.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/{calId}/acl".format(calId=calId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed insertacl" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute insertacl")

    async def getacl(
        self,
        calId: str,
        aclId: str
    ) -> ZoomResponse:
        """Get the specified ACL rule

        HTTP GET /calendars/{calId}/acl/{aclId}

        Args:
            calId: The calendar identifier. To retrieve calendar IDs, call the `calendarList.list` method.
            aclId: The ACL rule identifier.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/{calId}/acl/{aclId}".format(calId=calId, aclId=aclId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getacl" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getacl")

    async def deleteacl(
        self,
        calId: str,
        aclId: str
    ) -> ZoomResponse:
        """Delete an existing ACL rule

        HTTP DELETE /calendars/{calId}/acl/{aclId}

        Args:
            calId: The calendar identifier. To retrieve calendar IDs, call the `calendarList.list` method.
            aclId: The ACL rule identifier.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/{calId}/acl/{aclId}".format(calId=calId, aclId=aclId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed deleteacl" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute deleteacl")

    async def patchacl(
        self,
        calId: str,
        aclId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update the specified ACL rule

        HTTP PATCH /calendars/{calId}/acl/{aclId}

        Args:
            calId: The calendar identifier. To retrieve calendar IDs, call the `calendarList.list` method.
            aclId: The ACL rule identifier.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/{calId}/acl/{aclId}".format(calId=calId, aclId=aclId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed patchacl" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute patchacl")

    async def listcalendar_list(
        self,
        userIdentifier: str,
        *,
        maxResults: int | None = None,
        minAccessRole: str | None = None,
        pageToken: str | None = None,
        showDeleted: bool | None = None,
        showHidden: bool | None = None
    ) -> ZoomResponse:
        """List the calendars in the user's own calendarList

        HTTP GET /calendars/users/{userIdentifier}/calendarList

        Args:
            userIdentifier: The user identifier. It identifies which user's calendarList to operate.
            maxResults: The maximum number of entries returned on one result page.
            minAccessRole: The minimum access role for the user in the returned entries.
            pageToken: The token that specifies which result page to return.
            showDeleted: Whether to include deleted calendar list entries in the result.
            showHidden: Whether to show hidden entries.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if maxResults is not None:
            query_params['maxResults'] = str(maxResults)
        if minAccessRole is not None:
            query_params['minAccessRole'] = minAccessRole
        if pageToken is not None:
            query_params['pageToken'] = pageToken
        if showDeleted is not None:
            query_params['showDeleted'] = str(showDeleted).lower()
        if showHidden is not None:
            query_params['showHidden'] = str(showHidden).lower()

        url = self.base_url + "/calendars/users/{userIdentifier}/calendarList".format(userIdentifier=userIdentifier)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed listcalendar_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute listcalendar_list")

    async def insertcalendar_list(
        self,
        userIdentifier: str,
        body: dict[str, Any],
        *,
        colorRgbFormat: bool | None = None
    ) -> ZoomResponse:
        """Insert an existing calendar to the user's own calendarList

        HTTP POST /calendars/users/{userIdentifier}/calendarList

        Args:
            userIdentifier: The user identifier. It indicates which user's calendarList to operate.
            body: Request body payload
            colorRgbFormat: This parameter must be set to true when the user wants to change the foreground or background color.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if colorRgbFormat is not None:
            query_params['colorRgbFormat'] = str(colorRgbFormat).lower()

        url = self.base_url + "/calendars/users/{userIdentifier}/calendarList".format(userIdentifier=userIdentifier)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed insertcalendar_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute insertcalendar_list")

    async def getcalendar_list(
        self,
        userIdentifier: str,
        calendarId: str
    ) -> ZoomResponse:
        """Get a specified calendar from the user's own calendarList

        HTTP GET /calendars/users/{userIdentifier}/calendarList/{calendarId}

        Args:
            userIdentifier: The user identifier. It indicates Which user's calendarList to operate.
            calendarId: The calendar identifier. It specifies which calendarList entry in the user's calendarList to operate on. To retrieve cal

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/users/{userIdentifier}/calendarList/{calendarId}".format(userIdentifier=userIdentifier, calendarId=calendarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getcalendar_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getcalendar_list")

    async def deletecalendar_list(
        self,
        userIdentifier: str,
        calendarId: str
    ) -> ZoomResponse:
        """Delete an existing calendar from the user's own calendarList

        HTTP DELETE /calendars/users/{userIdentifier}/calendarList/{calendarId}

        Args:
            userIdentifier: The user identifier.  It indicates which user's calendarList to operate.
            calendarId: The calendar identifier. It specifies which calendarList entry in the user's calendarList to operate. To retrieve calend

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/users/{userIdentifier}/calendarList/{calendarId}".format(userIdentifier=userIdentifier, calendarId=calendarId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed deletecalendar_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute deletecalendar_list")

    async def patchcalendar_list(
        self,
        userIdentifier: str,
        calendarId: str,
        body: dict[str, Any],
        *,
        colorRgbFormat: bool | None = None
    ) -> ZoomResponse:
        """Update an existing calendar in the user's own calendarList

        HTTP PATCH /calendars/users/{userIdentifier}/calendarList/{calendarId}

        Args:
            userIdentifier: The user identifier. It indicates which user's calendarList to operate.
            calendarId: The calendar identifier. It specifies which calendarList entry in the user's calendarList to operate. To retrieve the ca
            body: Request body payload
            colorRgbFormat: This parameter must be set to true when user wants to change the foreground or background color.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if colorRgbFormat is not None:
            query_params['colorRgbFormat'] = str(colorRgbFormat).lower()

        url = self.base_url + "/calendars/users/{userIdentifier}/calendarList/{calendarId}".format(userIdentifier=userIdentifier, calendarId=calendarId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed patchcalendar_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute patchcalendar_list")

    async def insertcalendar(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a new secondary calendar

        HTTP POST /calendars

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed insertcalendar" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute insertcalendar")

    async def getcalendar(
        self,
        calId: str
    ) -> ZoomResponse:
        """Get the specified calendar

        HTTP GET /calendars/{calId}

        Args:
            calId: The calendar identifier. To retrieve calendar IDs, call the `calendarList.list` method.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/{calId}".format(calId=calId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getcalendar" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getcalendar")

    async def deletecalendar(
        self,
        calId: str
    ) -> ZoomResponse:
        """Delete a calendar owned by a user

        HTTP DELETE /calendars/{calId}

        Args:
            calId: The calendar ID of the calendar to be removed.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/{calId}".format(calId=calId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed deletecalendar" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute deletecalendar")

    async def patchcalendar(
        self,
        calId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update the specified calendar

        HTTP PATCH /calendars/{calId}

        Args:
            calId: The calendar identifier. To retrieve calendar IDs, call the `calendarList.list` method.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/{calId}".format(calId=calId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed patchcalendar" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute patchcalendar")

    async def getcolor(
        self
    ) -> ZoomResponse:
        """Get the color definitions for calendars and events

        HTTP GET /calendars/colors

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/colors"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getcolor" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getcolor")

    async def listevent(
        self,
        calId: str,
        *,
        maxResults: int | None = None,
        orderBy: str | None = None,
        showDeleted: bool | None = None,
        singleEvents: bool | None = None,
        pageToken: str | None = None,
        timeMax: str | None = None,
        timeMin: str | None = None,
        timeZone: str | None = None,
        syncToken: str | None = None
    ) -> ZoomResponse:
        """List events on the specified calendar

        HTTP GET /calendars/{calId}/events

        Args:
            calId: The calendar identifier. To retrieve calendar IDs, call the `calendarList.list` method.
            maxResults: The maximum number of events returned on one result page.
            orderBy: The order of the events returned in the result.
            showDeleted: Whether to include deleted events (with status equals "cancelled") in the result. Cancelled instances of recurring event
            singleEvents: Whether to expand recurring events into instances and only return single one-off events and instances of recurring event
            pageToken: The token that specifies which result page to return. Optional.
            timeMax: The upper bound (exclusive) for an event's start time to filter by. Optional. The default is not to filter by start time
            timeMin: The lower bound (exclusive) for an event's end time from which to filter. Optional. The default is not to filter by end
            timeZone: The time zone in the response. The default is the time zone of the calendar. Optional.
            syncToken: The `syncToken` records the time of the last event list. By providing this parameter, the event list results will only i

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if maxResults is not None:
            query_params['maxResults'] = str(maxResults)
        if orderBy is not None:
            query_params['orderBy'] = orderBy
        if showDeleted is not None:
            query_params['showDeleted'] = str(showDeleted).lower()
        if singleEvents is not None:
            query_params['singleEvents'] = str(singleEvents).lower()
        if pageToken is not None:
            query_params['pageToken'] = pageToken
        if timeMax is not None:
            query_params['timeMax'] = timeMax
        if timeMin is not None:
            query_params['timeMin'] = timeMin
        if timeZone is not None:
            query_params['timeZone'] = timeZone
        if syncToken is not None:
            query_params['syncToken'] = syncToken

        url = self.base_url + "/calendars/{calId}/events".format(calId=calId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed listevent" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute listevent")

    async def insertevent(
        self,
        calId: str,
        body: dict[str, Any],
        sendUpdates: str | None = None
    ) -> ZoomResponse:
        """Insert a new event to the specified calendar

        HTTP POST /calendars/{calId}/events

        Args:
            calId: The calendar identifier. To retrieve calendar IDs, call the `calendarList.list` method.
            body: Request body payload
            sendUpdates: Whether to send notifications about the creation of the new event. Note that some emails might still be sent.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if sendUpdates is not None:
            query_params['sendUpdates'] = sendUpdates

        url = self.base_url + "/calendars/{calId}/events".format(calId=calId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed insertevent" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute insertevent")

    async def importevent(
        self,
        calId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Import event to the specified calendar

        HTTP POST /calendars/{calId}/events/import

        Args:
            calId: The calendar identifier. To retrieve calendar IDs call the `calendarList.list` method.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/{calId}/events/import".format(calId=calId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed importevent" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute importevent")

    async def quickaddevent(
        self,
        calId: str,
        body: dict[str, Any],
        text: str | None = None,
        sendUpdates: str | None = None
    ) -> ZoomResponse:
        """Quick add an event to the specified calendar

        HTTP POST /calendars/{calId}/events/quickAdd

        Args:
            calId: The calendar identifier. To retrieve calendar IDs, call the `calendarList.list` method.
            body: Request body payload
            text: The text that describes the event to be created.
            sendUpdates: The guests who should receive notifications about the creation of the new event.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if text is not None:
            query_params['text'] = text
        if sendUpdates is not None:
            query_params['sendUpdates'] = sendUpdates

        url = self.base_url + "/calendars/{calId}/events/quickAdd".format(calId=calId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed quickaddevent" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute quickaddevent")

    async def getevent(
        self,
        calId: str,
        eventId: str
    ) -> ZoomResponse:
        """Get the specified event on the specified calendar

        HTTP GET /calendars/{calId}/events/{eventId}

        Args:
            calId: The calendar identifier. To retrieve calendar IDs, call the `calendarList.list` method.
            eventId: The event identifier.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/{calId}/events/{eventId}".format(calId=calId, eventId=eventId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getevent" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getevent")

    async def deleteevent(
        self,
        calId: str,
        eventId: str,
        sendUpdates: str | None = None
    ) -> ZoomResponse:
        """Delete an existing event from the specified calendar

        HTTP DELETE /calendars/{calId}/events/{eventId}

        Args:
            calId: The calendar identifier. To retrieve calendar IDs, call the `calendarList.list` method.
            eventId: The event identifier.
            sendUpdates: Whether to send notifications about the deletion of the event. Note that some emails might still be sent.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if sendUpdates is not None:
            query_params['sendUpdates'] = sendUpdates

        url = self.base_url + "/calendars/{calId}/events/{eventId}".format(calId=calId, eventId=eventId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed deleteevent" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute deleteevent")

    async def patchevent(
        self,
        calId: str,
        eventId: str,
        body: dict[str, Any],
        sendUpdates: str | None = None
    ) -> ZoomResponse:
        """Update the specified event on the specified calendar

        HTTP PATCH /calendars/{calId}/events/{eventId}

        Args:
            calId: The calendar identifier. To retrieve calendar IDs, call the `calendarList.list` method.
            eventId: The event identifier.
            body: Request body payload
            sendUpdates: The guests who should receive notifications about the event update.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if sendUpdates is not None:
            query_params['sendUpdates'] = sendUpdates

        url = self.base_url + "/calendars/{calId}/events/{eventId}".format(calId=calId, eventId=eventId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed patchevent" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute patchevent")

    async def instanceevent(
        self,
        calId: str,
        eventId: str,
        *,
        maxResults: int | None = None,
        showDeleted: bool | None = None,
        pageToken: str | None = None,
        timeMax: str | None = None,
        timeMin: str | None = None,
        timeZone: str | None = None
    ) -> ZoomResponse:
        """List all instances of the specified recurring event

        HTTP GET /calendars/{calId}/events/{eventId}/instances

        Args:
            calId: The calendar identifier. To retrieve calendar IDs, call the `calendarList.list` method.
            eventId: The event identifier.
            maxResults: The maximum number of events returned on one result page.
            showDeleted: Whether to include deleted events (with status equals "cancelled") in the result. Cancelled instances of recurring event
            pageToken: The token that specifies which result page to return. Optional.
            timeMax: The upper bound (exclusive) for an event's start time to filter by. Optional. The default is not to filter by start time
            timeMin: The lower bound (exclusive) for an event's end time to filter by. Optional. The default is not to filter by end time. Mu
            timeZone: The time zone in the response. Optional. The default is the time zone of the calendar.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if maxResults is not None:
            query_params['maxResults'] = str(maxResults)
        if showDeleted is not None:
            query_params['showDeleted'] = str(showDeleted).lower()
        if pageToken is not None:
            query_params['pageToken'] = pageToken
        if timeMax is not None:
            query_params['timeMax'] = timeMax
        if timeMin is not None:
            query_params['timeMin'] = timeMin
        if timeZone is not None:
            query_params['timeZone'] = timeZone

        url = self.base_url + "/calendars/{calId}/events/{eventId}/instances".format(calId=calId, eventId=eventId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed instanceevent" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute instanceevent")

    async def moveevent(
        self,
        calId: str,
        eventId: str,
        destination: str | None = None,
        sendUpdates: str | None = None
    ) -> ZoomResponse:
        """Move the specified event from a calendar to another specified calendar

        HTTP POST /calendars/{calId}/events/{eventId}/move

        Args:
            calId: The calendar identifier. To retrieve calendar IDs, call the `calendarList.list` method.
            eventId: The event identifier.
            destination: The calendar identifier of the target calendar where the event is to be moved.
            sendUpdates: Whether to send notifications about the creation of the new event. Note that some emails might still be sent.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if destination is not None:
            query_params['destination'] = destination
        if sendUpdates is not None:
            query_params['sendUpdates'] = sendUpdates

        url = self.base_url + "/calendars/{calId}/events/{eventId}/move".format(calId=calId, eventId=eventId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed moveevent" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute moveevent")

    async def queryfreebusy(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Query freebusy information for a set of calendars

        HTTP POST /calendars/freeBusy

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/freeBusy"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed queryfreebusy" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute queryfreebusy")

    async def listsettings(
        self,
        userIdentifier: str,
        maxResults: int | None = None,
        pageToken: str | None = None
    ) -> ZoomResponse:
        """List all user calendar settings of the authenticated user

        HTTP GET /calendars/users/{userIdentifier}/settings

        Args:
            userIdentifier: The user identifier. It indicates Which user's calendarList to operate.
            maxResults: The maximum number of entries returned on one result page.
            pageToken: The token that specifies which result page to return.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if maxResults is not None:
            query_params['maxResults'] = str(maxResults)
        if pageToken is not None:
            query_params['pageToken'] = pageToken

        url = self.base_url + "/calendars/users/{userIdentifier}/settings".format(userIdentifier=userIdentifier)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed listsettings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute listsettings")

    async def getsetting(
        self,
        userIdentifier: str,
        settingId: str
    ) -> ZoomResponse:
        """Get the specified user calendar settings of the authenticated user

        HTTP GET /calendars/users/{userIdentifier}/settings/{settingId}

        Args:
            userIdentifier: The user identifier.
            settingId: The identifier of the user setting. To retrieve calendar IDs, call the 'List all user settings' API.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/users/{userIdentifier}/settings/{settingId}".format(userIdentifier=userIdentifier, settingId=settingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getsetting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getsetting")

    async def patchsetting(
        self,
        userIdentifier: str,
        settingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Patch the specified user calendar settings of the authenticated user

        HTTP PATCH /calendars/users/{userIdentifier}/settings/{settingId}

        Args:
            userIdentifier: The user identifier.
            settingId: The ID of the setting to be patched.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/calendars/users/{userIdentifier}/settings/{settingId}".format(userIdentifier=userIdentifier, settingId=settingId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed patchsetting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute patchsetting")

    async def send_chatbot(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Send Chatbot messages

        HTTP POST /im/chat/messages

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/im/chat/messages"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed send_chatbot" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute send_chatbot")

    async def edit_chatbot_message(
        self,
        message_id: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Edit a Chatbot message

        HTTP PUT /im/chat/messages/{message_id}

        Args:
            message_id: The message ID. You can get this value from the [**Send Chatbot message**](/docs/api/rest/reference/chatbot/methods/#ope
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/im/chat/messages/{message_id}".format(message_id=message_id)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed edit_chatbot_message" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute edit_chatbot_message")

    async def delete_a_chatbot_message(
        self,
        message_id: str,
        account_id: str | None = None,
        user_jid: str | None = None,
        robot_jid: str | None = None
    ) -> ZoomResponse:
        """Delete a Chatbot message

        HTTP DELETE /im/chat/messages/{message_id}

        Args:
            message_id: The message ID. You can get this value from the [**Send Chatbot message**](/docs/api/rest/reference/chatbot/methods/#ope
            account_id: The account ID to which the message was sent. You can get this value from the [Chatbot request sent to your server](/doc
            user_jid: The JID of the user on whose behalf the message is being sent. This is used to prevent members of a channel from getting
            robot_jid: The robot JID. This is created when enabling Chatbot features on your Marketplace app.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if account_id is not None:
            query_params['account_id'] = account_id
        if user_jid is not None:
            query_params['user_jid'] = user_jid
        if robot_jid is not None:
            query_params['robot_jid'] = robot_jid

        url = self.base_url + "/im/chat/messages/{message_id}".format(message_id=message_id)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_a_chatbot_message" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_a_chatbot_message")

    async def unfurling_link(
        self,
        userId: str,
        triggerId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Link Unfurls

        HTTP POST /im/chat/users/{userId}/unfurls/{triggerId}

        Args:
            userId: The unique identifier of the user.
            triggerId: The unique identification of the unfurling request. It can come from the `team_chat.link_shared` webhook.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/im/chat/users/{userId}/unfurls/{triggerId}".format(userId=userId, triggerId=triggerId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed unfurling_link" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute unfurling_link")

    async def get_clip_collaborators(
        self,
        clipId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get collaborators of a clip

        HTTP GET /clips/{clipId}/collaborators

        Args:
            clipId: The clip's ID.
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/clips/{clipId}/collaborators".format(clipId=clipId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_clip_collaborators" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_clip_collaborators")

    async def delete_collaborator(
        self,
        clipId: str,
        user_key: str | None = None,
        channel_id: str | None = None
    ) -> ZoomResponse:
        """Remove the collaborator from a clip

        HTTP DELETE /clips/{clipId}/collaborators

        Args:
            clipId: The clip's ID.
            user_key: The collaborator user email or collaborator user ID.
            channel_id: The channel ID.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if user_key is not None:
            query_params['user_key'] = user_key
        if channel_id is not None:
            query_params['channel_id'] = channel_id

        url = self.base_url + "/clips/{clipId}/collaborators".format(clipId=clipId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_collaborator" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_collaborator")

    async def listclipcomments(
        self,
        clipId: str,
        page_size: str | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List clip comments

        HTTP GET /clips/{clipId}/comments

        Args:
            clipId: The clip's ID.
            page_size: The number of records returned per page in a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns when the available results excee

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = page_size
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/clips/{clipId}/comments".format(clipId=clipId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed listclipcomments" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute listclipcomments")

    async def deleteacomment(
        self,
        clipId: str,
        commentId: str
    ) -> ZoomResponse:
        """Delete a comment

        HTTP DELETE /clips/{clipId}/comments/{commentId}

        Args:
            clipId: The clip's ID.
            commentId: The clip's comment ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/clips/{clipId}/comments/{commentId}".format(clipId=clipId, commentId=commentId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed deleteacomment" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute deleteacomment")

    async def get_clip_by_id(
        self,
        clipId: str
    ) -> ZoomResponse:
        """Get a clip

        HTTP GET /clips/{clipId}

        Args:
            clipId: The clip's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/clips/{clipId}".format(clipId=clipId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_clip_by_id" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_clip_by_id")

    async def delete_clip(
        self,
        clipId: str
    ) -> ZoomResponse:
        """Delete a clip(soft delete)

        HTTP DELETE /clips/{clipId}

        Args:
            clipId: The clip's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/clips/{clipId}".format(clipId=clipId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_clip" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_clip")

    async def transferclipsowner(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Transfer clips owner

        HTTP POST /clips/transfers

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/clips/transfers"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed transferclipsowner" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute transferclipsowner")

    async def transfertaskstatuscheck(
        self,
        taskId: str
    ) -> ZoomResponse:
        """Transfer task status check

        HTTP GET /clips/transfers/{taskId}

        Args:
            taskId: The unique ID of this transfer request for logging/correlation.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/clips/transfers/{taskId}".format(taskId=taskId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed transfertaskstatuscheck" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute transfertaskstatuscheck")

    async def upload_clip_file(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Upload clip file

        HTTP POST /clips/files

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/clips/files"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed upload_clip_file" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute upload_clip_file")

    async def upload_iq_multipart_clip_file(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Upload clip multipart files

        HTTP POST /clips/files/multipart

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/clips/files/multipart"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed upload_iq_multipart_clip_file" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute upload_iq_multipart_clip_file")

    async def initiate_and_complete_a_clip_multipart_upload(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Initiate and complete the multipart file upload for a clip

        HTTP POST /clips/files/multipart/upload_events

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/clips/files/multipart/upload_events"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed initiate_and_complete_a_clip_multipart_upload" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute initiate_and_complete_a_clip_multipart_upload")

    async def get_user_clips(
        self,
        page_size: str | None = None,
        next_page_token: str | None = None,
        user_id: str | None = None,
        search_key: str | None = None,
        date_filter_type: str | None = None,
        from_: str | None = None,
        to: str | None = None
    ) -> ZoomResponse:
        """List all clips

        HTTP GET /clips

        Args:
            page_size: The number of records returned per page in a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns when the available results excee
            user_id: The email address or user ID of the clip owner. Providing this parameter will return only the clip owned by the specifie
            search_key: The name of a clip. Providing this parameter enables the system to return only the matching clip. Otherwise, all clips w
            date_filter_type: The clip date filter type. Enum:  CREATED_DATE - clip create date. MODIFIED_DATE - clip modify date.
            from_: The queried start date and time in yyyy-MM-dd'T'HH:mm:ss'Z' UTC format for the created date range for which you would li
            to: The queried end date and time in yyyy-MM-dd'T'HH:mm:ss'Z' UTC format.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = page_size
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if user_id is not None:
            query_params['user_id'] = user_id
        if search_key is not None:
            query_params['search_key'] = search_key
        if date_filter_type is not None:
            query_params['date_filter_type'] = date_filter_type
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to

        url = self.base_url + "/clips"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_user_clips" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_user_clips")

    async def get_cisco_polycom_room_account_setting(
        self
    ) -> ZoomResponse:
        """Get Cisco/Polycom Room Account Setting

        HTTP GET /crc/managed_rooms/account_setting

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/managed_rooms/account_setting"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_cisco_polycom_room_account_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_cisco_polycom_room_account_setting")

    async def update_cisco_polycom_room_account_setting(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update Cisco/Polycom Room Account Setting

        HTTP PATCH /crc/managed_rooms/account_setting

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/managed_rooms/account_setting"

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_cisco_polycom_room_account_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_cisco_polycom_room_account_setting")

    async def get_list_api_connectors(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List API Connectors

        HTTP GET /crc/api_connectors

        Args:
            page_size: Query parameter
            next_page_token: Query parameter

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/crc/api_connectors"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_list_api_connectors" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_list_api_connectors")

    async def create_api_connector(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create an API Connector

        HTTP POST /crc/api_connectors

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/api_connectors"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_api_connector" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_api_connector")

    async def get_api_connector(
        self,
        connectorId: str
    ) -> ZoomResponse:
        """Get an API Connector

        HTTP GET /crc/api_connectors/{connectorId}

        Args:
            connectorId: The enhanced API connector's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/api_connectors/{connectorId}".format(connectorId=connectorId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_api_connector" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_api_connector")

    async def delete_api_connector(
        self,
        connectorId: str
    ) -> ZoomResponse:
        """Delete an API Connector

        HTTP DELETE /crc/api_connectors/{connectorId}

        Args:
            connectorId: The enhanced API connector's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/api_connectors/{connectorId}".format(connectorId=connectorId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_api_connector" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_api_connector")

    async def update_api_connector(
        self,
        connectorId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update an API Connector

        HTTP PATCH /crc/api_connectors/{connectorId}

        Args:
            connectorId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/api_connectors/{connectorId}".format(connectorId=connectorId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_api_connector" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_api_connector")

    async def getan_api_connector_sprivatekey(
        self,
        connectorId: str
    ) -> ZoomResponse:
        """Get an API Connector's private key

        HTTP GET /crc/api_connectors/{connectorId}/private_key

        Args:
            connectorId: The enhanced API connector's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/api_connectors/{connectorId}/private_key".format(connectorId=connectorId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getan_api_connector_sprivatekey" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getan_api_connector_sprivatekey")

    async def update_api_connector_private_key(
        self,
        connectorId: str
    ) -> ZoomResponse:
        """Update an API Connector's private key

        HTTP PATCH /crc/api_connectors/{connectorId}/private_key

        Args:
            connectorId: The enhanced API connector's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/api_connectors/{connectorId}/private_key".format(connectorId=connectorId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_api_connector_private_key" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_api_connector_private_key")

    async def list_managed_rooms(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List Managed Rooms

        HTTP GET /crc/managed_rooms

        Args:
            page_size: Query parameter
            next_page_token: Query parameter

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/crc/managed_rooms"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_managed_rooms" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_managed_rooms")

    async def createa_managed_room(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a Managed Room

        HTTP POST /crc/managed_rooms

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/managed_rooms"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed createa_managed_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute createa_managed_room")

    async def geta_managed_room(
        self,
        deviceId: str
    ) -> ZoomResponse:
        """Get a Managed Room

        HTTP GET /crc/managed_rooms/{deviceId}

        Args:
            deviceId: The Cisco or Polycom Room's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/managed_rooms/{deviceId}".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed geta_managed_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute geta_managed_room")

    async def deleteamanagedroom(
        self,
        deviceId: str
    ) -> ZoomResponse:
        """Delete a managed room

        HTTP DELETE /crc/managed_rooms/{deviceId}

        Args:
            deviceId: The Cisco/Polycom Room's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/managed_rooms/{deviceId}".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed deleteamanagedroom" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute deleteamanagedroom")

    async def updatea_managed_room(
        self,
        deviceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a Managed Room

        HTTP PATCH /crc/managed_rooms/{deviceId}

        Args:
            deviceId: The Cisco/Polycom Room's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/managed_rooms/{deviceId}".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed updatea_managed_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute updatea_managed_room")

    async def get_participant_identifier_code(
        self,
        expires_in: int | None = None
    ) -> ZoomResponse:
        """Get participant identifier code

        HTTP GET /crc/participant_identifier_code

        Args:
            expires_in: Optional time to live param for identifier code. Default value is 43200, Min value is 30.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if expires_in is not None:
            query_params['expires_in'] = str(expires_in)

        url = self.base_url + "/crc/participant_identifier_code"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_participant_identifier_code" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_participant_identifier_code")

    async def list_room_templates(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List Room Templates

        HTTP GET /crc/room_templates

        Args:
            page_size: Query parameter
            next_page_token: Query parameter

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/crc/room_templates"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_room_templates" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_room_templates")

    async def createa_room_template(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a Room Template

        HTTP POST /crc/room_templates

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/room_templates"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed createa_room_template" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute createa_room_template")

    async def geta_room_template(
        self,
        templateId: str
    ) -> ZoomResponse:
        """Get a Room Template

        HTTP GET /crc/room_templates/{templateId}

        Args:
            templateId: The Cisco/Polycom Rooms Template's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/room_templates/{templateId}".format(templateId=templateId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed geta_room_template" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute geta_room_template")

    async def deletearoomtemplate(
        self,
        templateId: str
    ) -> ZoomResponse:
        """Delete a room template

        HTTP DELETE /crc/room_templates/{templateId}

        Args:
            templateId: The Cisco/Polycom Rooms Template's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/room_templates/{templateId}".format(templateId=templateId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed deletearoomtemplate" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute deletearoomtemplate")

    async def updatea_room_template(
        self,
        templateId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a Room Template

        HTTP PATCH /crc/room_templates/{templateId}

        Args:
            templateId: The Cisco/Polycom Rooms Template's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/crc/room_templates/{templateId}".format(templateId=templateId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed updatea_room_template" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute updatea_room_template")

    async def list_draft_emails(
        self,
        email: str,
        *,
        includeSpamTrash: bool | None = None,
        maxResults: int | None = None,
        pageToken: str | None = None,
        q: str | None = None
    ) -> ZoomResponse:
        """List emails from draft folder

        HTTP GET /emails/mailboxes/{email}/drafts

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            includeSpamTrash: Include messages from SPAM and TRASH in the results. Value should be either "true" or "false".
            maxResults: Maximum number of drafts to return. This field defaults to 50. The maximum allowed value for this field is 500.
            pageToken: Page token to retrieve a specific page of results in the list.
            q: Specify a server side elastic search query.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if includeSpamTrash is not None:
            query_params['includeSpamTrash'] = str(includeSpamTrash).lower()
        if maxResults is not None:
            query_params['maxResults'] = str(maxResults)
        if pageToken is not None:
            query_params['pageToken'] = pageToken
        if q is not None:
            query_params['q'] = q

        url = self.base_url + "/emails/mailboxes/{email}/drafts".format(email=email)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_draft_emails" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_draft_emails")

    async def create_draft_email(
        self,
        email: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a new draft email

        HTTP POST /emails/mailboxes/{email}/drafts

        Args:
            email: The mailbox's email address, or special value "me" to indicate the primary mailbox for the authenticated user.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/drafts".format(email=email)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_draft_email" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_draft_email")

    async def send_draft_email(
        self,
        email: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Send out a draft email

        HTTP POST /emails/mailboxes/{email}/drafts/send

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/drafts/send".format(email=email)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed send_draft_email" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute send_draft_email")

    async def get_draft_email(
        self,
        email: str,
        draftId: str,
        format_: str | None = None
    ) -> ZoomResponse:
        """Get the specified draft email

        HTTP GET /emails/mailboxes/{email}/drafts/{draftId}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            draftId: The immutable ID of the draft.
            format_: The format to return the draft in.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if format_ is not None:
            query_params['format'] = format_

        url = self.base_url + "/emails/mailboxes/{email}/drafts/{draftId}".format(email=email, draftId=draftId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_draft_email" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_draft_email")

    async def update_draft_email(
        self,
        email: str,
        draftId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update the specified draft email

        HTTP PUT /emails/mailboxes/{email}/drafts/{draftId}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            draftId: The immutable ID of the draft.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/drafts/{draftId}".format(email=email, draftId=draftId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_draft_email" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_draft_email")

    async def delete_draft_email(
        self,
        email: str,
        draftId: str
    ) -> ZoomResponse:
        """Delete an existing draft email

        HTTP DELETE /emails/mailboxes/{email}/drafts/{draftId}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            draftId: The immutable ID of the draft.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/drafts/{draftId}".format(email=email, draftId=draftId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_draft_email" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_draft_email")

    async def list_mailbox_history(
        self,
        email: str,
        maxResults: int | None = None,
        pageToken: str | None = None,
        startHistoryId: str | None = None,
        historyTypes: str | None = None,
        excludeHistoryTypes: str | None = None,
        labelId: str | None = None
    ) -> ZoomResponse:
        """List history of events for mailbox

        HTTP GET /emails/mailboxes/{email}/history

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            maxResults: Maximum number of history events to return. This field defaults to 50. The maximum allowed value is 500.
            pageToken: The page token to retrieve a specific page of results in the list.
            startHistoryId: Returns history records after the specified `startHistoryId`. The supplied `startHistoryId` should be obtained from the
            historyTypes: History types to be returned by the function.  If one history type included in both query parameters``historyType`` and
            excludeHistoryTypes: History types not to be returned by the function.  If one history type included in both query parameters ``historyTypes`
            labelId: Only return messages with a label matching the ID.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if maxResults is not None:
            query_params['maxResults'] = str(maxResults)
        if pageToken is not None:
            query_params['pageToken'] = pageToken
        if startHistoryId is not None:
            query_params['startHistoryId'] = startHistoryId
        if historyTypes is not None:
            query_params['historyTypes'] = historyTypes
        if excludeHistoryTypes is not None:
            query_params['excludeHistoryTypes'] = excludeHistoryTypes
        if labelId is not None:
            query_params['labelId'] = labelId

        url = self.base_url + "/emails/mailboxes/{email}/history".format(email=email)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_mailbox_history" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_mailbox_history")

    async def list_labels_in_mailbox(
        self,
        email: str,
        format_: str | None = None
    ) -> ZoomResponse:
        """List labels in the mailbox

        HTTP GET /emails/mailboxes/{email}/labels

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            format_: Enum value to control how much label information is returned.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if format_ is not None:
            query_params['format'] = format_

        url = self.base_url + "/emails/mailboxes/{email}/labels".format(email=email)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_labels_in_mailbox" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_labels_in_mailbox")

    async def create_label_in_mailbox(
        self,
        email: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a new label in mailbox

        HTTP POST /emails/mailboxes/{email}/labels

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/labels".format(email=email)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_label_in_mailbox" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_label_in_mailbox")

    async def get_label_in_mailbox(
        self,
        email: str,
        labelId: str
    ) -> ZoomResponse:
        """Get the specified label in mailbox

        HTTP GET /emails/mailboxes/{email}/labels/{labelId}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            labelId: The ID of the label to retrieve.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/labels/{labelId}".format(email=email, labelId=labelId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_label_in_mailbox" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_label_in_mailbox")

    async def update_label_in_mailbox(
        self,
        email: str,
        labelId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update the specified label in mailbox

        HTTP PUT /emails/mailboxes/{email}/labels/{labelId}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            labelId: The ID of the label to update.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/labels/{labelId}".format(email=email, labelId=labelId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_label_in_mailbox" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_label_in_mailbox")

    async def delete_label_from_mailbox(
        self,
        email: str,
        labelId: str
    ) -> ZoomResponse:
        """Delete an existing label from mailbox

        HTTP DELETE /emails/mailboxes/{email}/labels/{labelId}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            labelId: The ID of the label to delete.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/labels/{labelId}".format(email=email, labelId=labelId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_label_from_mailbox" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_label_from_mailbox")

    async def patch_label_in_mailbox(
        self,
        email: str,
        labelId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Patch the specified label in mailbox

        HTTP PATCH /emails/mailboxes/{email}/labels/{labelId}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            labelId: The ID of the label to patch.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/labels/{labelId}".format(email=email, labelId=labelId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed patch_label_in_mailbox" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute patch_label_in_mailbox")

    async def get_mailbox_profile(
        self,
        email: str
    ) -> ZoomResponse:
        """Get the mailbox profile

        HTTP GET /emails/mailboxes/{email}/profile

        Args:
            email: The mailbox address, or the unique value “me” indicates the primary mailbox for the authenticated user.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/profile".format(email=email)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_mailbox_profile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_mailbox_profile")

    async def list_emails(
        self,
        email: str,
        *,
        maxResults: str | None = None,
        pageToken: str | None = None,
        labelIds: str | None = None,
        q: str | None = None,
        includeSpamTrash: bool | None = None
    ) -> ZoomResponse:
        """List emails from the mailbox

        HTTP GET /emails/mailboxes/{email}/messages

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            maxResults: Maximum number of messages to return. This field defaults to 50. The maximum allowed value for this field is 500.
            pageToken: Page token to retrieve a specific page of results in the list.
            labelIds: Only return messages with labels that match all of the specified label IDs in this query parameter.
            q: Only return messages matching the specified elastic search query.
            includeSpamTrash: Whether to include messages from SPAM and TRASH in the results.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if maxResults is not None:
            query_params['maxResults'] = maxResults
        if pageToken is not None:
            query_params['pageToken'] = pageToken
        if labelIds is not None:
            query_params['labelIds'] = labelIds
        if q is not None:
            query_params['q'] = q
        if includeSpamTrash is not None:
            query_params['includeSpamTrash'] = str(includeSpamTrash).lower()

        url = self.base_url + "/emails/mailboxes/{email}/messages".format(email=email)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_emails" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_emails")

    async def create_email(
        self,
        email: str,
        body: dict[str, Any],
        *,
        deleted: bool | None = None
    ) -> ZoomResponse:
        """Create a new email

        HTTP POST /emails/mailboxes/{email}/messages

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            body: Request body payload
            deleted: Mark the inserting email directly as TRASH if this query parameter is set to true.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if deleted is not None:
            query_params['deleted'] = str(deleted).lower()

        url = self.base_url + "/emails/mailboxes/{email}/messages".format(email=email)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_email" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_email")

    async def batch_delete_emails(
        self,
        email: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Batch delete the specified emails

        HTTP POST /emails/mailboxes/{email}/messages/batchDelete

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/messages/batchDelete".format(email=email)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed batch_delete_emails" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute batch_delete_emails")

    async def batch_modify_emails(
        self,
        email: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Batch modify the specified emails

        HTTP POST /emails/mailboxes/{email}/messages/batchModify

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/messages/batchModify".format(email=email)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed batch_modify_emails" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute batch_modify_emails")

    async def send_email(
        self,
        email: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Send out an email

        HTTP POST /emails/mailboxes/{email}/messages/send

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/messages/send".format(email=email)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed send_email" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute send_email")

    async def get_email(
        self,
        email: str,
        messageId: str,
        format_: str | None = None,
        metadataHeaders: str | None = None
    ) -> ZoomResponse:
        """Get the specified email

        HTTP GET /emails/mailboxes/{email}/messages/{messageId}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            messageId: The ID of the message to retrieve.
            format_: The format to return the message with.
            metadataHeaders: When requested format is metadata, only include headers specified in this query parameter.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if format_ is not None:
            query_params['format'] = format_
        if metadataHeaders is not None:
            query_params['metadataHeaders'] = metadataHeaders

        url = self.base_url + "/emails/mailboxes/{email}/messages/{messageId}".format(email=email, messageId=messageId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_email" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_email")

    async def delete_email(
        self,
        email: str,
        messageId: str
    ) -> ZoomResponse:
        """Delete an existing email

        HTTP DELETE /emails/mailboxes/{email}/messages/{messageId}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            messageId: The ID of the message to delete.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/messages/{messageId}".format(email=email, messageId=messageId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_email" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_email")

    async def update_email(
        self,
        email: str,
        messageId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update the specified email

        HTTP POST /emails/mailboxes/{email}/messages/{messageId}/modify

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            messageId: The ID of the message to modify.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/messages/{messageId}/modify".format(email=email, messageId=messageId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_email" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_email")

    async def trash_email(
        self,
        email: str,
        messageId: str
    ) -> ZoomResponse:
        """Move the specified email to TRASH folder

        HTTP POST /emails/mailboxes/{email}/messages/{messageId}/trash

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            messageId: The ID of the message to trash.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/messages/{messageId}/trash".format(email=email, messageId=messageId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed trash_email" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute trash_email")

    async def untrash_email(
        self,
        email: str,
        messageId: str
    ) -> ZoomResponse:
        """Move the specified email out of TRASH folder

        HTTP POST /emails/mailboxes/{email}/messages/{messageId}/untrash

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            messageId: The ID of the message to untrash.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/messages/{messageId}/untrash".format(email=email, messageId=messageId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed untrash_email" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute untrash_email")

    async def get_email_attachment(
        self,
        email: str,
        messageId: str,
        attachmentId: str
    ) -> ZoomResponse:
        """Get the specified attachment for an email

        HTTP GET /emails/mailboxes/{email}/messages/{messageId}/attachments/{attachmentId}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            messageId: The ID of the message to retrieve attachment from.
            attachmentId: The ID of the attachment to retrieve.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/messages/{messageId}/attachments/{attachmentId}".format(email=email, messageId=messageId, attachmentId=attachmentId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_email_attachment" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_email_attachment")

    async def get_mail_vacation_response_setting(
        self,
        email: str
    ) -> ZoomResponse:
        """Get mailbox vacation response setting

        HTTP GET /emails/mailboxes/{email}/settings/vacation

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/settings/vacation".format(email=email)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_mail_vacation_response_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_mail_vacation_response_setting")

    async def update_mailbox_vacation_response_setting(
        self,
        email: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update mailbox vacation response setting

        HTTP PUT /emails/mailboxes/{email}/settings/vacation

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/settings/vacation".format(email=email)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_mailbox_vacation_response_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_mailbox_vacation_response_setting")

    async def list_mailbox_delegates(
        self,
        email: str
    ) -> ZoomResponse:
        """List delegates on the mailbox

        HTTP GET /emails/mailboxes/{email}/settings/delegates

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/settings/delegates".format(email=email)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_mailbox_delegates" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_mailbox_delegates")

    async def grant_mailbox_delegate(
        self,
        email: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Grant a new delegate access on the mailbox

        HTTP POST /emails/mailboxes/{email}/settings/delegates

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/settings/delegates".format(email=email)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed grant_mailbox_delegate" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute grant_mailbox_delegate")

    async def get_mailbox_delegate(
        self,
        email: str,
        delegateEmail: str
    ) -> ZoomResponse:
        """Get the specified delegate on the mailbox

        HTTP GET /emails/mailboxes/{email}/settings/delegates/{delegateEmail}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            delegateEmail: The delegate email address.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/settings/delegates/{delegateEmail}".format(email=email, delegateEmail=delegateEmail)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_mailbox_delegate" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_mailbox_delegate")

    async def revoke_mailbox_delegate(
        self,
        email: str,
        delegateEmail: str
    ) -> ZoomResponse:
        """Revoke an existing delegate access from the mailbox

        HTTP DELETE /emails/mailboxes/{email}/settings/delegates/{delegateEmail}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            delegateEmail: The delegate user's email address.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/settings/delegates/{delegateEmail}".format(email=email, delegateEmail=delegateEmail)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed revoke_mailbox_delegate" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute revoke_mailbox_delegate")

    async def list_email_filters(
        self,
        email: str
    ) -> ZoomResponse:
        """List email filters

        HTTP GET /emails/mailboxes/{email}/settings/filters

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/settings/filters".format(email=email)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_email_filters" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_email_filters")

    async def create_email_filter(
        self,
        email: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create an email filter

        HTTP POST /emails/mailboxes/{email}/settings/filters

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/settings/filters".format(email=email)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_email_filter" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_email_filter")

    async def get_email_filter(
        self,
        email: str,
        filterId: str
    ) -> ZoomResponse:
        """Get the specified email filter

        HTTP GET /emails/mailboxes/{email}/settings/filters/{filterId}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            filterId: The ID of the filter to be fetched.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/settings/filters/{filterId}".format(email=email, filterId=filterId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_email_filter" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_email_filter")

    async def delete_email_filter(
        self,
        email: str,
        filterId: str
    ) -> ZoomResponse:
        """Delete the specified email filter

        HTTP DELETE /emails/mailboxes/{email}/settings/filters/{filterId}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            filterId: The ID of the filter to be deleted.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/settings/filters/{filterId}".format(email=email, filterId=filterId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_email_filter" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_email_filter")

    async def list_email_threads(
        self,
        email: str,
        includeSpamTrash: str | None = None,
        labelIds: str | None = None,
        maxResults: str | None = None,
        pageToken: str | None = None,
        q: str | None = None
    ) -> ZoomResponse:
        """List email threads from the mailbox

        HTTP GET /emails/mailboxes/{email}/threads

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            includeSpamTrash: Whether or not to include threads from SPAM and TRASH folders in the results.
            labelIds: Only return threads with message labels that match all of the specified label IDs in this query parameter.
            maxResults: Maximum number of threads to return.  It defaults to 50. The maximum allowed value for this parameter is 500.
            pageToken: Page token to retrieve a specific page of results in the list.
            q: Only return threads matching the specified elastic search query.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if includeSpamTrash is not None:
            query_params['includeSpamTrash'] = includeSpamTrash
        if labelIds is not None:
            query_params['labelIds'] = labelIds
        if maxResults is not None:
            query_params['maxResults'] = maxResults
        if pageToken is not None:
            query_params['pageToken'] = pageToken
        if q is not None:
            query_params['q'] = q

        url = self.base_url + "/emails/mailboxes/{email}/threads".format(email=email)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_email_threads" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_email_threads")

    async def get_email_thread(
        self,
        email: str,
        threadId: str,
        format_: str | None = None,
        metadataHeaders: str | None = None,
        maxResults: str | None = None,
        pageToken: str | None = None
    ) -> ZoomResponse:
        """Get the specified email thread

        HTTP GET /emails/mailboxes/{email}/threads/{threadId}

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            threadId: The ID of the thread to retrieve.
            format_: The format to return the messages in.
            metadataHeaders: When requested format is metadata, only include headers specified in this query parameter.
            maxResults: Maximum number of thread messages to return. This field defaults to 50. The maximum allowed value for this field is 500.
            pageToken: Page token to retrieve a specific page of results in the list.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if format_ is not None:
            query_params['format'] = format_
        if metadataHeaders is not None:
            query_params['metadataHeaders'] = metadataHeaders
        if maxResults is not None:
            query_params['maxResults'] = maxResults
        if pageToken is not None:
            query_params['pageToken'] = pageToken

        url = self.base_url + "/emails/mailboxes/{email}/threads/{threadId}".format(email=email, threadId=threadId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_email_thread" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_email_thread")

    async def delete_email_thread(
        self,
        email: str,
        threadId: str
    ) -> ZoomResponse:
        """Delete an existing email thread

        HTTP DELETE /emails/mailboxes/{email}/threads/{threadId}

        Args:
            email: The user's email address, or special value "me" to indicate the authenticated user from the access token.
            threadId: The ID of the thread to delete.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/threads/{threadId}".format(email=email, threadId=threadId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_email_thread" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_email_thread")

    async def update_email_thread(
        self,
        email: str,
        threadId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update the specified thread

        HTTP POST /emails/mailboxes/{email}/threads/{threadId}/modify

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            threadId: The ID of the thread to retrieve.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/threads/{threadId}/modify".format(email=email, threadId=threadId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_email_thread" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_email_thread")

    async def trash_email_thread(
        self,
        email: str,
        threadId: str
    ) -> ZoomResponse:
        """Move the specified thread to TRASH folder

        HTTP POST /emails/mailboxes/{email}/threads/{threadId}/trash

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            threadId: The ID of the thread to trash.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/threads/{threadId}/trash".format(email=email, threadId=threadId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed trash_email_thread" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute trash_email_thread")

    async def untrash_email_thread(
        self,
        email: str,
        threadId: str
    ) -> ZoomResponse:
        """Move the specified thread out of TRASH folder

        HTTP POST /emails/mailboxes/{email}/threads/{threadId}/untrash

        Args:
            email: The mailbox address, or special value "me" to indicate the primary mailbox for the authenticated user.
            threadId: The ID of the thread to remove from the trash.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/emails/mailboxes/{email}/threads/{threadId}/untrash".format(email=email, threadId=threadId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed untrash_email_thread" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute untrash_email_thread")

    async def list_archived_files(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        query_date_type: str | None = None,
        group_id: str | None = None,
        group_ids: str | None = None
    ) -> ZoomResponse:
        """List archived files

        HTTP GET /archive_files

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            from_: The query start date, in `yyyy-MM-dd'T'HH:mm:ssZ` format. This value and the `to` query parameter value cannot exceed se
            to: The query end date, in `yyyy-MM-dd'T'HH:mm:ssZ` format. This value and the `from` query parameter value cannot exceed se
            query_date_type: The type of query date. * `meeting_start_time`  * `archive_complete_time`    This value defaults to `meeting_start_time`
            group_id: Deprecated. Please use 'group_ids' for querying.
            group_ids: The group IDs. To get a group ID, use the [List groups](/docs/api/rest/reference/scim-api/methods/#operation/groupSCIM2L

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if query_date_type is not None:
            query_params['query_date_type'] = query_date_type
        if group_id is not None:
            query_params['group_id'] = group_id
        if group_ids is not None:
            query_params['group_ids'] = group_ids

        url = self.base_url + "/archive_files"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_archived_files" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_archived_files")

    async def get_archived_file_statistics(
        self,
        from_: str | None = None,
        to: str | None = None
    ) -> ZoomResponse:
        """Get archived file statistics

        HTTP GET /archive_files/statistics

        Args:
            from_: The query start date, in `yyyy-MM-dd'T'HH:mm:ssZ` format. This value and the `to` query parameter value cannot exceed se
            to: The query end date, in `yyyy-MM-dd'T'HH:mm:ssZ` format. This value and the `from` query parameter value cannot exceed se

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to

        url = self.base_url + "/archive_files/statistics"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_archived_file_statistics" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_archived_file_statistics")

    async def update_archived_file(
        self,
        fileId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update an archived file's auto-delete status

        HTTP PATCH /archive_files/{fileId}

        Args:
            fileId: Archived file ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/archive_files/{fileId}".format(fileId=fileId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_archived_file" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_archived_file")

    async def get_archived_files(
        self,
        meetingUUID: str
    ) -> ZoomResponse:
        """Get a meeting's archived files

        HTTP GET /past_meetings/{meetingUUID}/archive_files

        Args:
            meetingUUID: The meeting's universally unique identifier (UUID). Each meeting instance generates a UUID. After a meeting ends, a new

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/past_meetings/{meetingUUID}/archive_files".format(meetingUUID=meetingUUID)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_archived_files" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_archived_files")

    async def delete_archived_files(
        self,
        meetingUUID: str
    ) -> ZoomResponse:
        """Delete a meeting's archived files

        HTTP DELETE /past_meetings/{meetingUUID}/archive_files

        Args:
            meetingUUID: The meeting's universally unique identifier (UUID). Each meeting instance generates a UUID. For example, after a meeting

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/past_meetings/{meetingUUID}/archive_files".format(meetingUUID=meetingUUID)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_archived_files" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_archived_files")

    async def recording_get(
        self,
        meetingId: str,
        include_fields: str | None = None,
        ttl: int | None = None
    ) -> ZoomResponse:
        """Get meeting recordings

        HTTP GET /meetings/{meetingId}/recordings

        Args:
            meetingId: To get a meeting's cloud recordings, provide the meeting ID or UUID. If providing the meeting ID instead of UUID, the re
            include_fields: Include fields in the response. Currently, only accepts `download_access_token` to get this token field and value for do
            ttl: The `download_access_token` Time to Live (TTL) value. This parameter is only valid if the `include_fields` query paramet

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if include_fields is not None:
            query_params['include_fields'] = include_fields
        if ttl is not None:
            query_params['ttl'] = str(ttl)

        url = self.base_url + "/meetings/{meetingId}/recordings".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed recording_get" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute recording_get")

    async def recording_delete(
        self,
        meetingId: str,
        action: str | None = None
    ) -> ZoomResponse:
        """Delete meeting or webinar recordings

        HTTP DELETE /meetings/{meetingId}/recordings

        Args:
            meetingId: To get a meeting's cloud recordings, provide the meeting ID or meeting UUID. If the meeting ID is provided instead of UU
            action: The recording delete actions.    `trash` - Move recording to trash.    `delete` - Delete recording permanently.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if action is not None:
            query_params['action'] = action

        url = self.base_url + "/meetings/{meetingId}/recordings".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed recording_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute recording_delete")

    async def analytics_details(
        self,
        meetingId: str,
        page_size: int | None = None,
        next_page_token: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        type_: str | None = None
    ) -> ZoomResponse:
        """Get a meeting or webinar recording's analytics details

        HTTP GET /meetings/{meetingId}/recordings/analytics_details

        Args:
            meetingId: To get a meeting's cloud recordings, provide the meeting ID or meeting UUID. If the meeting ID is provided instead of UU
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            from_: The start date for the monthly range to query. The maximum range can be a month. If you do not provide this value, this
            to: The end date for the monthly range to query. The maximum range can be a month.
            type_: The type of analytics details:  * `by_view` &mdash; by_view.  * `by_download` &mdash; by_download.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if type_ is not None:
            query_params['type'] = type_

        url = self.base_url + "/meetings/{meetingId}/recordings/analytics_details".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed analytics_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute analytics_details")

    async def analytics_summary(
        self,
        meetingId: str,
        from_: str | None = None,
        to: str | None = None
    ) -> ZoomResponse:
        """Get a meeting or webinar recording's analytics summary

        HTTP GET /meetings/{meetingId}/recordings/analytics_summary

        Args:
            meetingId: To get a meeting's cloud recordings, provide the meeting ID or meeting UUID. If the meeting ID is provided instead of UU
            from_: The start date for the monthly range to query. The maximum range can be a month. If you do not provide this value, this
            to: The end date for the monthly range to query. The maximum range can be a month.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to

        url = self.base_url + "/meetings/{meetingId}/recordings/analytics_summary".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed analytics_summary" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute analytics_summary")

    async def meeting_recording_registrants(
        self,
        meetingId: str,
        status: str | None = None,
        page_size: int | None = None,
        page_number: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List recording registrants

        HTTP GET /meetings/{meetingId}/recordings/registrants

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            status: Query by the registrant's status.  * `pending` - The registration is pending.  * `approved` - The registrant is approved
            page_size: The number of records returned within a single API call.
            page_number: **Deprecated.** We will no longer support this field in a future release. Instead, use the `next_page_token` for paginat
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if status is not None:
            query_params['status'] = status
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if page_number is not None:
            query_params['page_number'] = str(page_number)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/meetings/{meetingId}/recordings/registrants".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_recording_registrants" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_recording_registrants")

    async def meeting_recording_registrant_create(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a recording registrant

        HTTP POST /meetings/{meetingId}/recordings/registrants

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/recordings/registrants".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_recording_registrant_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_recording_registrant_create")

    async def recording_registrants_questions_get(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Get registration questions

        HTTP GET /meetings/{meetingId}/recordings/registrants/questions

        Args:
            meetingId: To get a meeting's cloud recordings, provide the meeting ID or meeting UUID. If the meeting ID is provided instead of UU

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/recordings/registrants/questions".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed recording_registrants_questions_get" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute recording_registrants_questions_get")

    async def recording_registrant_question_update(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update registration questions

        HTTP PATCH /meetings/{meetingId}/recordings/registrants/questions

        Args:
            meetingId: To get a meeting's cloud recordings, provide the meeting ID or meeting UUID. If the meeting ID is provided instead of UU
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/recordings/registrants/questions".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed recording_registrant_question_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute recording_registrant_question_update")

    async def meeting_recording_registrant_status(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a registrant's status

        HTTP PUT /meetings/{meetingId}/recordings/registrants/status

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/recordings/registrants/status".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_recording_registrant_status" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_recording_registrant_status")

    async def recording_setting_update(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Get meeting recording settings

        HTTP GET /meetings/{meetingId}/recordings/settings

        Args:
            meetingId: The meeting ID lets you get cloud recording of a meeting or webinar. * Meeting - Provide the meeting ID or meeting UUID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/recordings/settings".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed recording_setting_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute recording_setting_update")

    async def recording_settings_update(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update meeting recording settings

        HTTP PATCH /meetings/{meetingId}/recordings/settings

        Args:
            meetingId: To get cloud recordings of a meeting, provide the meeting ID or meeting UUID. If the meeting ID is provided instead of U
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/recordings/settings".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed recording_settings_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute recording_settings_update")

    async def recording_delete_one(
        self,
        meetingId: str,
        recordingId: str,
        action: str | None = None
    ) -> ZoomResponse:
        """Delete a recording file for a meeting or webinar

        HTTP DELETE /meetings/{meetingId}/recordings/{recordingId}

        Args:
            meetingId: To get a meeting's cloud recordings, provide the meeting ID or meeting UUID. If the meeting ID is provided instead of UU
            recordingId: The recording ID.
            action: The recording delete actions.   `trash` - Move recording to trash.    `delete` - Delete recording permanently.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if action is not None:
            query_params['action'] = action

        url = self.base_url + "/meetings/{meetingId}/recordings/{recordingId}".format(meetingId=meetingId, recordingId=recordingId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed recording_delete_one" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute recording_delete_one")

    async def recording_status_update_one(
        self,
        meetingId: str,
        recordingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Recover a single recording

        HTTP PUT /meetings/{meetingId}/recordings/{recordingId}/status

        Args:
            meetingId: To get a meeting's cloud recordings, provide the meeting ID or meeting UUID. If the meeting ID is provided instead of UU
            recordingId: The recording ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/recordings/{recordingId}/status".format(meetingId=meetingId, recordingId=recordingId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed recording_status_update_one" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute recording_status_update_one")

    async def get_meeting_transcript(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Get a meeting transcript

        HTTP GET /meetings/{meetingId}/transcript

        Args:
            meetingId: To get a meeting's transcript, provide the meeting ID or meeting UUID. If the meeting ID is provided instead of UUID, th

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/transcript".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_meeting_transcript" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_meeting_transcript")

    async def delete_meeting_transcript(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Delete a meeting or webinar transcript

        HTTP DELETE /meetings/{meetingId}/transcript

        Args:
            meetingId: To delete a meeting's transcript, provide the meeting ID or meeting's unique universal identifier (UUID). If the meeting

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/transcript".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_meeting_transcript" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_meeting_transcript")

    async def recording_status_update(
        self,
        meetingUUID: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Recover meeting recordings

        HTTP PUT /meetings/{meetingUUID}/recordings/status

        Args:
            meetingUUID: The meeting's universally unique identifier (UUID). Each meeting instance generates a UUID. For example, after a meeting
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingUUID}/recordings/status".format(meetingUUID=meetingUUID)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed recording_status_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute recording_status_update")

    async def recordings_list(
        self,
        userId: str,
        *,
        page_size: int | None = None,
        next_page_token: str | None = None,
        mc: str | None = None,
        trash: bool | None = None,
        from_: str | None = None,
        to: str | None = None,
        trash_type: str | None = None,
        meeting_id: int | None = None
    ) -> ZoomResponse:
        """List all recordings

        HTTP GET /users/{userId}/recordings

        Args:
            userId: The user's ID or email address. For user-level apps, pass the `me` value.
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            mc: The query metadata of the recording if using an on-premise meeting connector for the meeting.
            trash: The query trash. * `true` - List recordings from trash.   * `false` - Do not list recordings from the trash.    The defa
            from_: The start date in 'yyyy-mm-dd' UTC format for the date range where you would like to retrieve recordings. The maximum ra
            to: The end date in 'yyyy-mm-dd' 'yyyy-mm-dd' UTC format.
            trash_type: The type of cloud recording to retrieve from the trash.     *   `meeting_recordings`: List all meeting recordings from t
            meeting_id: The meeting ID.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if mc is not None:
            query_params['mc'] = mc
        if trash is not None:
            query_params['trash'] = str(trash).lower()
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if trash_type is not None:
            query_params['trash_type'] = trash_type
        if meeting_id is not None:
            query_params['meeting_id'] = str(meeting_id)

        url = self.base_url + "/users/{userId}/recordings".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed recordings_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute recordings_list")

    async def list_devices(
        self,
        *,
        search_text: str | None = None,
        platform_os: str | None = None,
        is_enrolled_in_zdm: bool | None = None,
        device_type: int | None = None,
        device_vendor: str | None = None,
        device_model: str | None = None,
        device_status: int | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List devices

        HTTP GET /devices

        Args:
            search_text: Filter devices by name or serial number.
            platform_os: Filter devices by platform operating system.
            is_enrolled_in_zdm: Filter devices by enrollment of ZDM (Zoom Device Management).
            device_type: Filter devices by device type.     Device Type:    `-1` - All Zoom Room device(0,1,2,3,4,6).    `0` - Zoom Rooms Compute
            device_vendor: Filter devices by vendor.
            device_model: Filter devices by model.
            device_status: Filter devices by status.      Device Status:    `0` - offline.    `1` - online.    `-1` - unlink
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if search_text is not None:
            query_params['search_text'] = search_text
        if platform_os is not None:
            query_params['platform_os'] = platform_os
        if is_enrolled_in_zdm is not None:
            query_params['is_enrolled_in_zdm'] = str(is_enrolled_in_zdm).lower()
        if device_type is not None:
            query_params['device_type'] = str(device_type)
        if device_vendor is not None:
            query_params['device_vendor'] = device_vendor
        if device_model is not None:
            query_params['device_model'] = device_model
        if device_status is not None:
            query_params['device_status'] = str(device_status)
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/devices"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_devices" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_devices")

    async def add_device(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a new device

        HTTP POST /devices

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/devices"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_device" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_device")

    async def getzdmgroupinfo(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get ZDM group info

        HTTP GET /devices/groups

        Args:
            page_size: The total number of records returned from a single API call. Default - 30. Max -100.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/devices/groups"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getzdmgroupinfo" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getzdmgroupinfo")

    async def assigndevicetoauser_commonarea(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign a device to a user or commonarea

        HTTP POST /devices/zpa/assignment

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/devices/zpa/assignment"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assigndevicetoauser_commonarea" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assigndevicetoauser_commonarea")

    async def get_zpa_device_list_profile_setting_ofa_user(
        self,
        user_id: str | None = None
    ) -> ZoomResponse:
        """Get Zoom Phone Appliance settings by user ID

        HTTP GET /devices/zpa/settings

        Args:
            user_id: The user's ID or email address. For user-level apps, pass `me` as the value for `user_id`.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if user_id is not None:
            query_params['user_id'] = user_id

        url = self.base_url + "/devices/zpa/settings"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_zpa_device_list_profile_setting_ofa_user" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_zpa_device_list_profile_setting_ofa_user")

    async def upgrade_zpas_app(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Upgrade ZPA firmware or app

        HTTP POST /devices/zpa/upgrade

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/devices/zpa/upgrade"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed upgrade_zpas_app" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute upgrade_zpas_app")

    async def delete_zpa_device_by_vendor_and_mac_address(
        self,
        vendor: str,
        macAddress: str
    ) -> ZoomResponse:
        """Delete ZPA device by vendor and mac address

        HTTP DELETE /devices/zpa/vendors/{vendor}/mac_addresses/{macAddress}

        Args:
            vendor: The device's manufacturer.
            macAddress: The device's mac address.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/devices/zpa/vendors/{vendor}/mac_addresses/{macAddress}".format(vendor=vendor, macAddress=macAddress)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_zpa_device_by_vendor_and_mac_address" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_zpa_device_by_vendor_and_mac_address")

    async def get_zpa_versioninfo(
        self,
        zdmGroupId: str
    ) -> ZoomResponse:
        """Get ZPA version info

        HTTP GET /devices/zpa/zdm_groups/{zdmGroupId}/versions

        Args:
            zdmGroupId: The Zoom Device Management (ZDM) group ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/devices/zpa/zdm_groups/{zdmGroupId}/versions".format(zdmGroupId=zdmGroupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_zpa_versioninfo" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_zpa_versioninfo")

    async def get_device(
        self,
        deviceId: str
    ) -> ZoomResponse:
        """Get device detail

        HTTP GET /devices/{deviceId}

        Args:
            deviceId: The device's unique identifier.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/devices/{deviceId}".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_device" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_device")

    async def delete_device(
        self,
        deviceId: str
    ) -> ZoomResponse:
        """Delete device

        HTTP DELETE /devices/{deviceId}

        Args:
            deviceId: Unique identifier of the device.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/devices/{deviceId}".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_device" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_device")

    async def update_device(
        self,
        deviceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Change device

        HTTP PATCH /devices/{deviceId}

        Args:
            deviceId: Unique identifier of the device.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/devices/{deviceId}".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_device" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_device")

    async def assgin_group(
        self,
        deviceId: str,
        group_id: str | None = None
    ) -> ZoomResponse:
        """Assign a device to a group

        HTTP PATCH /devices/{deviceId}/assign_group

        Args:
            deviceId: The device ID.
            group_id: The group's ID.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if group_id is not None:
            query_params['group_id'] = group_id

        url = self.base_url + "/devices/{deviceId}/assign_group".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assgin_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assgin_group")

    async def change_device_association(
        self,
        deviceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Change device association

        HTTP PATCH /devices/{deviceId}/assignment

        Args:
            deviceId: The device's unique identifier.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/devices/{deviceId}/assignment".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed change_device_association" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute change_device_association")

    async def device_list(
        self,
        page_size: int | None = None,
        page_number: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List H.323/SIP devices

        HTTP GET /h323/devices

        Args:
            page_size: The number of records returned within a single API call.
            page_number: **Deprecated.** We will no longer support this field in a future release. Instead, use the `next_page_token` for paginat
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if page_number is not None:
            query_params['page_number'] = str(page_number)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/h323/devices"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed device_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute device_list")

    async def device_create(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a H.323/SIP device

        HTTP POST /h323/devices

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/h323/devices"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed device_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute device_create")

    async def device_delete(
        self,
        deviceId: str
    ) -> ZoomResponse:
        """Delete a H.323/SIP device

        HTTP DELETE /h323/devices/{deviceId}

        Args:
            deviceId: The device ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/h323/devices/{deviceId}".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed device_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute device_delete")

    async def device_update(
        self,
        deviceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a H.323/SIP device

        HTTP PATCH /h323/devices/{deviceId}

        Args:
            deviceId: The device ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/h323/devices/{deviceId}".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed device_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute device_update")

    async def delete_meeting_chat_message_by_id(
        self,
        meetingId: str,
        messageId: str,
        file_ids: str | None = None
    ) -> ZoomResponse:
        """Delete a live meeting message

        HTTP DELETE /live_meetings/{meetingId}/chat/messages/{messageId}

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, store it as a long-format integer and **not** an integer.
            messageId: The live meeting chat message's unique identifier (UUID), in base64-encoded format.
            file_ids: The live webinar chat file's universally unique identifier, in base64-encoded format. Separate multiple values with comm

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if file_ids is not None:
            query_params['file_ids'] = file_ids

        url = self.base_url + "/live_meetings/{meetingId}/chat/messages/{messageId}".format(meetingId=meetingId, messageId=messageId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_meeting_chat_message_by_id" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_meeting_chat_message_by_id")

    async def update_meeting_chat_message_by_id(
        self,
        meetingId: str,
        messageId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a live meeting message

        HTTP PATCH /live_meetings/{meetingId}/chat/messages/{messageId}

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, store it as a long-format integer and **not** an integer.
            messageId: The live meeting chat message's unique identifier (UUID), in base64-encoded format.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/live_meetings/{meetingId}/chat/messages/{messageId}".format(meetingId=meetingId, messageId=messageId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_meeting_chat_message_by_id" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_meeting_chat_message_by_id")

    async def in_meeting_control(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Use in-meeting controls

        HTTP PATCH /live_meetings/{meetingId}/events

        Args:
            meetingId: The live meeting's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/live_meetings/{meetingId}/events".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed in_meeting_control" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute in_meeting_control")

    async def meeting_rtms_status_update(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update participant Real-Time Media Streams (RTMS) app status

        HTTP PATCH /live_meetings/{meetingId}/rtms_app/status

        Args:
            meetingId: The meeting's ID.  When storing this value in your database, store it as a long format integer and **not** an integer. M
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/live_meetings/{meetingId}/rtms_app/status".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_rtms_status_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_rtms_status_update")

    async def listmeetingsummaries(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        from_: str | None = None,
        to: str | None = None
    ) -> ZoomResponse:
        """List an account's meeting or webinar summaries

        HTTP GET /meetings/meeting_summaries

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through a large set of results. The next page token returns whenever the set of avai
            from_: The start date, in `yyyy-MM-dd'T'HH:mm:ss'Z'` UTC format, used to retrieve the meeting summaries' creation date range.
            to: The end date, in `yyyy-MM-dd'T'HH:mm:ss'Z'` UTC format, used to retrieve the meeting summaries' creation date range.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to

        url = self.base_url + "/meetings/meeting_summaries"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed listmeetingsummaries" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute listmeetingsummaries")

    async def meeting(
        self,
        meetingId: str,
        *,
        occurrence_id: str | None = None,
        show_previous_occurrences: bool | None = None
    ) -> ZoomResponse:
        """Get a meeting

        HTTP GET /meetings/{meetingId}

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, store it as a long format integer and **not** an integer.
            occurrence_id: Meeting occurrence ID. Provide this field to view meeting details of a particular occurrence of the [recurring meeting](
            show_previous_occurrences: Set this field's value to `true` to view meeting details of all previous occurrences of a [recurring meeting](https://su

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_id is not None:
            query_params['occurrence_id'] = occurrence_id
        if show_previous_occurrences is not None:
            query_params['show_previous_occurrences'] = str(show_previous_occurrences).lower()

        url = self.base_url + "/meetings/{meetingId}".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting")

    async def meeting_delete(
        self,
        meetingId: str,
        *,
        occurrence_id: str | None = None,
        schedule_for_reminder: bool | None = None,
        cancel_meeting_reminder: bool | None = None
    ) -> ZoomResponse:
        """Delete a meeting

        HTTP DELETE /meetings/{meetingId}

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            occurrence_id: The meeting or webinar occurrence ID.
            schedule_for_reminder: `true`: Notify host and alternative host about the meeting cancellation via email. `false`: Do not send any email notifi
            cancel_meeting_reminder: `true`: Notify registrants about the meeting cancellation via email.   `false`: Do not send any email notification to me

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_id is not None:
            query_params['occurrence_id'] = occurrence_id
        if schedule_for_reminder is not None:
            query_params['schedule_for_reminder'] = str(schedule_for_reminder).lower()
        if cancel_meeting_reminder is not None:
            query_params['cancel_meeting_reminder'] = str(cancel_meeting_reminder).lower()

        url = self.base_url + "/meetings/{meetingId}".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_delete")

    async def meeting_update(
        self,
        meetingId: str,
        body: dict[str, Any],
        occurrence_id: str | None = None
    ) -> ZoomResponse:
        """Update a meeting

        HTTP PATCH /meetings/{meetingId}

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, store it as a long format integer and **not** an integer.
            body: Request body payload
            occurrence_id: Meeting occurrence ID. Support change of agenda, `start_time`, duration, or settings {`host_video`, `participant_video`,

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_id is not None:
            query_params['occurrence_id'] = occurrence_id

        url = self.base_url + "/meetings/{meetingId}".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_update")

    async def create_batch_polls(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Perform batch poll creation

        HTTP POST /meetings/{meetingId}/batch_polls

        Args:
            meetingId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/batch_polls".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_batch_polls" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_batch_polls")

    async def add_batch_registrants(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Perform batch registration

        HTTP POST /meetings/{meetingId}/batch_registrants

        Args:
            meetingId: Unique identifier of the meeting (Meeting Number).
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/batch_registrants".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_batch_registrants" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_batch_registrants")

    async def meeting_invitation(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Get meeting invitation

        HTTP GET /meetings/{meetingId}/invitation

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer, not a simple

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/invitation".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_invitation" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_invitation")

    async def meeting_invite_links_create(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a meeting's invite links

        HTTP POST /meetings/{meetingId}/invite_links

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/invite_links".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_invite_links_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_invite_links_create")

    async def meeting_live_streaming_join_token(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Get a meeting's join token for live streaming

        HTTP GET /meetings/{meetingId}/jointoken/live_streaming

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/jointoken/live_streaming".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_live_streaming_join_token" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_live_streaming_join_token")

    async def meeting_local_archiving_archive_token(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Get a meeting's archive token for local archiving

        HTTP GET /meetings/{meetingId}/jointoken/local_archiving

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/jointoken/local_archiving".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_local_archiving_archive_token" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_local_archiving_archive_token")

    async def meeting_local_recording_join_token(
        self,
        meetingId: str,
        *,
        bypass_waiting_room: bool | None = None
    ) -> ZoomResponse:
        """Get a meeting's join token for local recording

        HTTP GET /meetings/{meetingId}/jointoken/local_recording

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            bypass_waiting_room: Whether to bypass the waiting room.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if bypass_waiting_room is not None:
            query_params['bypass_waiting_room'] = str(bypass_waiting_room).lower()

        url = self.base_url + "/meetings/{meetingId}/jointoken/local_recording".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_local_recording_join_token" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_local_recording_join_token")

    async def get_meeting_live_stream_details(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Get livestream details

        HTTP GET /meetings/{meetingId}/livestream

        Args:
            meetingId: Unique identifier of the meeting.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/livestream".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_meeting_live_stream_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_meeting_live_stream_details")

    async def meeting_live_stream_update(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a livestream

        HTTP PATCH /meetings/{meetingId}/livestream

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/livestream".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_live_stream_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_live_stream_update")

    async def meeting_live_stream_status_update(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update livestream status

        HTTP PATCH /meetings/{meetingId}/livestream/status

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/livestream/status".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_live_stream_status_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_live_stream_status_update")

    async def getameetingsummary(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Get a meeting or webinar summary

        HTTP GET /meetings/{meetingId}/meeting_summary

        Args:
            meetingId: The meeting's universally unique ID (UUID). When you provide a meeting UUID that begins with a `/` character or contains

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/meeting_summary".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getameetingsummary" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getameetingsummary")

    async def deletemeetingorwebinarsummary(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Delete a meeting or webinar summary

        HTTP DELETE /meetings/{meetingId}/meeting_summary

        Args:
            meetingId: The meeting's universally unique ID (UUID). When you provide a meeting UUID that begins with a `/` character or contains

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/meeting_summary".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed deletemeetingorwebinarsummary" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute deletemeetingorwebinarsummary")

    async def meeting_app_add(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Add a meeting app

        HTTP POST /meetings/{meetingId}/open_apps

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/open_apps".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_app_add" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_app_add")

    async def meeting_app_delete(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Delete a meeting app

        HTTP DELETE /meetings/{meetingId}/open_apps

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/open_apps".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_app_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_app_delete")

    async def meeting_polls(
        self,
        meetingId: str,
        *,
        anonymous: bool | None = None
    ) -> ZoomResponse:
        """List meeting polls

        HTTP GET /meetings/{meetingId}/polls

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            anonymous: Whether to query for polls with the **Anonymous** option enabled:  * `true` &mdash; Query for polls with the **Anonymous

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if anonymous is not None:
            query_params['anonymous'] = str(anonymous).lower()

        url = self.base_url + "/meetings/{meetingId}/polls".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_polls" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_polls")

    async def meeting_poll_create(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a meeting poll

        HTTP POST /meetings/{meetingId}/polls

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/polls".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_poll_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_poll_create")

    async def meeting_poll_get(
        self,
        meetingId: str,
        pollId: str
    ) -> ZoomResponse:
        """Get a meeting poll

        HTTP GET /meetings/{meetingId}/polls/{pollId}

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, store it as a `long` format integer, not a simple integer
            pollId: The poll ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/polls/{pollId}".format(meetingId=meetingId, pollId=pollId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_poll_get" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_poll_get")

    async def meeting_poll_update(
        self,
        meetingId: str,
        pollId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a meeting poll

        HTTP PUT /meetings/{meetingId}/polls/{pollId}

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            pollId: The poll ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/polls/{pollId}".format(meetingId=meetingId, pollId=pollId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_poll_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_poll_update")

    async def meeting_poll_delete(
        self,
        meetingId: str,
        pollId: str
    ) -> ZoomResponse:
        """Delete a meeting poll

        HTTP DELETE /meetings/{meetingId}/polls/{pollId}

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            pollId: The poll ID

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/polls/{pollId}".format(meetingId=meetingId, pollId=pollId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_poll_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_poll_delete")

    async def meeting_registrants(
        self,
        meetingId: str,
        occurrence_id: str | None = None,
        status: str | None = None,
        page_size: int | None = None,
        page_number: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List meeting registrants

        HTTP GET /meetings/{meetingId}/registrants

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, store it as a long format integer, not an integer. Meetin
            occurrence_id: The meeting or webinar occurrence ID.
            status: Query by the registrant's status.  * `pending` - The registration is pending.  * `approved` - The registrant is approved
            page_size: The number of records returned within a single API call.
            page_number: **Deprecated.** We will no longer support this field in a future release. Instead, use the `next_page_token` for paginat
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_id is not None:
            query_params['occurrence_id'] = occurrence_id
        if status is not None:
            query_params['status'] = status
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if page_number is not None:
            query_params['page_number'] = str(page_number)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/meetings/{meetingId}/registrants".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_registrants" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_registrants")

    async def meeting_registrant_create(
        self,
        meetingId: str,
        body: dict[str, Any],
        occurrence_ids: str | None = None
    ) -> ZoomResponse:
        """Add a meeting registrant

        HTTP POST /meetings/{meetingId}/registrants

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            body: Request body payload
            occurrence_ids: A comma-separated list of meeting occurrence IDs. You can get this value with the [Get a meeting](/docs/api-reference/zo

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_ids is not None:
            query_params['occurrence_ids'] = occurrence_ids

        url = self.base_url + "/meetings/{meetingId}/registrants".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_registrant_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_registrant_create")

    async def meeting_registrants_questions_get(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """List registration questions

        HTTP GET /meetings/{meetingId}/registrants/questions

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, store it as a long format integer, not a simple integer.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/registrants/questions".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_registrants_questions_get" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_registrants_questions_get")

    async def meeting_registrant_question_update(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update registration questions

        HTTP PATCH /meetings/{meetingId}/registrants/questions

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/registrants/questions".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_registrant_question_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_registrant_question_update")

    async def meeting_registrant_status(
        self,
        meetingId: str,
        body: dict[str, Any],
        occurrence_id: str | None = None
    ) -> ZoomResponse:
        """Update registrant's status

        HTTP PUT /meetings/{meetingId}/registrants/status

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, store it as a `long` format integer, not as a simple inte
            body: Request body payload
            occurrence_id: The meeting or webinar occurrence ID.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_id is not None:
            query_params['occurrence_id'] = occurrence_id

        url = self.base_url + "/meetings/{meetingId}/registrants/status".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_registrant_status" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_registrant_status")

    async def meeting_registrant_get(
        self,
        meetingId: str,
        registrantId: str
    ) -> ZoomResponse:
        """Get a meeting registrant

        HTTP GET /meetings/{meetingId}/registrants/{registrantId}

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            registrantId: The registrant ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/registrants/{registrantId}".format(meetingId=meetingId, registrantId=registrantId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_registrant_get" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_registrant_get")

    async def meetingregistrantdelete(
        self,
        meetingId: str,
        registrantId: str,
        occurrence_id: str | None = None
    ) -> ZoomResponse:
        """Delete a meeting registrant

        HTTP DELETE /meetings/{meetingId}/registrants/{registrantId}

        Args:
            meetingId: The meeting ID.
            registrantId: The meeting registrant ID.
            occurrence_id: The meeting occurrence ID.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_id is not None:
            query_params['occurrence_id'] = occurrence_id

        url = self.base_url + "/meetings/{meetingId}/registrants/{registrantId}".format(meetingId=meetingId, registrantId=registrantId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meetingregistrantdelete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meetingregistrantdelete")

    async def get_sip_dialing_with_passcode(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Get a meeting SIP URI with passcode

        HTTP POST /meetings/{meetingId}/sip_dialing

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/sip_dialing".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_sip_dialing_with_passcode" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_sip_dialing_with_passcode")

    async def meeting_status(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update meeting status

        HTTP PUT /meetings/{meetingId}/status

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a `long` format integer and not an i
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/status".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_status" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_status")

    async def meeting_survey_get(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Get a meeting survey

        HTTP GET /meetings/{meetingId}/survey

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, store it as a long-format integer and **not** a simple in

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/survey".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_survey_get" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_survey_get")

    async def meeting_survey_delete(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Delete a meeting survey

        HTTP DELETE /meetings/{meetingId}/survey

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/survey".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_survey_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_survey_delete")

    async def meeting_survey_update(
        self,
        meetingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a meeting survey

        HTTP PATCH /meetings/{meetingId}/survey

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, store it as a long-format integer and **not** a simple in
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/meetings/{meetingId}/survey".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_survey_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_survey_update")

    async def meeting_token(
        self,
        meetingId: str,
        type_: str | None = None
    ) -> ZoomResponse:
        """Get meeting's token

        HTTP GET /meetings/{meetingId}/token

        Args:
            meetingId: The meeting's ID.    When storing this value in your database, you must store it as a long format integer and **not** an
            type_: The meeting token type.  * `closed_caption_token` - The third-party closed caption API token.   This defaults to `closed

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_

        url = self.base_url + "/meetings/{meetingId}/token".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_token" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_token")

    async def past_meeting_details(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Get past meeting details

        HTTP GET /past_meetings/{meetingId}

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API will return a response for the

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/past_meetings/{meetingId}".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed past_meeting_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute past_meeting_details")

    async def past_meetings(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """List past meeting instances

        HTTP GET /past_meetings/{meetingId}/instances

        Args:
            meetingId: The past meeting's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/past_meetings/{meetingId}/instances".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed past_meetings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute past_meetings")

    async def past_meeting_participants(
        self,
        meetingId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get past meeting participants

        HTTP GET /past_meetings/{meetingId}/participants

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API will return a response for the
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/past_meetings/{meetingId}/participants".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed past_meeting_participants" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute past_meeting_participants")

    async def list_past_meeting_polls(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """List past meeting's poll results

        HTTP GET /past_meetings/{meetingId}/polls

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API will return a response for the

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/past_meetings/{meetingId}/polls".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_past_meeting_polls" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_past_meeting_polls")

    async def list_past_meeting_qa(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """List past meetings' Q&A

        HTTP GET /past_meetings/{meetingId}/qa

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API will return a response for the

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/past_meetings/{meetingId}/qa".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_past_meeting_qa" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_past_meeting_qa")

    async def list_meeting_templates(
        self,
        userId: str
    ) -> ZoomResponse:
        """List meeting templates

        HTTP GET /users/{userId}/meeting_templates

        Args:
            userId: The user ID retrievable from the [List users](/api-reference/zoom-api/methods#operation/users) API.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/meeting_templates".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_meeting_templates" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_meeting_templates")

    async def meeting_template_create(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a meeting template from an existing meeting

        HTTP POST /users/{userId}/meeting_templates

        Args:
            userId: The user ID retrievable from the [List users](/docs/api/rest/reference/user/methods/#operation/users) API.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/meeting_templates".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_template_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_template_create")

    async def meetings(
        self,
        userId: str,
        type_: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        page_number: int | None = None,
        from_: str | None = None,
        to: str | None = None,
        timezone: str | None = None
    ) -> ZoomResponse:
        """List meetings

        HTTP GET /users/{userId}/meetings

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            type_: The type of meeting.  * `scheduled` - All valid previous (unexpired) meetings, live meetings, and upcoming scheduled mee
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            page_number: The page number of the current page in the returned records.
            from_: The start date.
            to: The end date.
            timezone: The timezone to assign to the `from` and `to` value. For a list of supported timezones and their formats, see our [timez

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_number is not None:
            query_params['page_number'] = str(page_number)
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if timezone is not None:
            query_params['timezone'] = timezone

        url = self.base_url + "/users/{userId}/meetings".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meetings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meetings")

    async def meeting_create(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a meeting

        HTTP POST /users/{userId}/meetings

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/meetings".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed meeting_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute meeting_create")

    async def list_upcoming_meeting(
        self,
        userId: str
    ) -> ZoomResponse:
        """List upcoming meetings

        HTTP GET /users/{userId}/upcoming_meetings

        Args:
            userId: The user's user ID or email address. For user-level apps, pass [the `me` value](/docs/api/rest/using-zoom-apis/#the-me-k

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/upcoming_meetings".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_upcoming_meeting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_upcoming_meeting")

    async def user_pa_cs(
        self,
        userId: str
    ) -> ZoomResponse:
        """List a user's PAC accounts

        HTTP GET /users/{userId}/pac

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/pac".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_pa_cs" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_pa_cs")

    async def report_sign_in_sign_out_activities(
        self,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get sign In / sign out activity report

        HTTP GET /report/activities

        Args:
            from_: Start date for which you would like to view the activity logs report. Using the `from` and `to` parameters, specify a mo
            to: End date up to which you would like to view the activity logs report.
            page_size: The number of records to be returned within a single API call
            next_page_token: Next page token is used to paginate through large result sets

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/report/activities"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_sign_in_sign_out_activities" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_sign_in_sign_out_activities")

    async def get_billing_report(
        self
    ) -> ZoomResponse:
        """Get billing reports

        HTTP GET /report/billing

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/report/billing"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_billing_report" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_billing_report")

    async def get_billing_invoices_reports(
        self,
        billing_id: str | None = None
    ) -> ZoomResponse:
        """Get billing invoice reports

        HTTP GET /report/billing/invoices

        Args:
            billing_id: The billing report's unique identifier. Retrieve this ID from the response of **Get Billing Reports** API request.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if billing_id is not None:
            query_params['billing_id'] = billing_id

        url = self.base_url + "/report/billing/invoices"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_billing_invoices_reports" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_billing_invoices_reports")

    async def report_cloud_recording(
        self,
        from_: str | None = None,
        to: str | None = None,
        group_id: str | None = None
    ) -> ZoomResponse:
        """Get cloud recording usage report

        HTTP GET /report/cloud_recording

        Args:
            from_: Start date in 'yyyy-mm-dd' format. The date range defined by the &quot;from&quot; and &quot;to&quot; parameters should o
            to: End date.
            group_id: The group ID. To get a group ID, use the [**List groups**](/api-reference/zoom-api/methods#operation/groups) API.    **N

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if group_id is not None:
            query_params['group_id'] = group_id

        url = self.base_url + "/report/cloud_recording"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_cloud_recording" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_cloud_recording")

    async def report_daily(
        self,
        year: int | None = None,
        month: int | None = None,
        group_id: str | None = None
    ) -> ZoomResponse:
        """Get daily usage report

        HTTP GET /report/daily

        Args:
            year: Year for this report
            month: Month for this report
            group_id: The group ID. To get a group ID, use the [**List groups**](/docs/api/users/#tag/groups/GET/groups) API.    **Note:** The

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if year is not None:
            query_params['year'] = str(year)
        if month is not None:
            query_params['month'] = str(month)
        if group_id is not None:
            query_params['group_id'] = group_id

        url = self.base_url + "/report/daily"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_daily" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_daily")

    async def gethistorymeetingandwebinarlist(
        self,
        from_: str | None = None,
        to: str | None = None,
        date_type: str | None = None,
        meeting_type: str | None = None,
        report_type: str | None = None,
        search_key: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        group_id: str | None = None,
        meeting_feature: str | None = None
    ) -> ZoomResponse:
        """Get history meeting and webinar list

        HTTP GET /report/history_meetings

        Args:
            from_: The start date in `yyyy-mm-dd` format. The date range defined by the `from` and `to` parameters should only be one month
            to: The end date in `yyyy-mm-dd` format.
            date_type: The type of date to query. * `start_time` - Query by meeting's start time.  * `end_time` - Query by meeting's end time.
            meeting_type: The meeting type to query.  - `all` - rerturn meetings and webinars  - `meeting` - only return meetings  - `webinar` - o
            report_type: Query meetings that have this type of report. - `all` - all meetings - `poll` - meetings with poll data  - `survey` - me
            search_key: The keywords of meeting topic or meeting ID.
            page_size: The number of records to be returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            group_id: The group ID. To get a group ID, use the [**List groups**](/docs/api/rest/reference/user/methods/#operation/groups) API.
            meeting_feature: The meeting features to query and return history meetings that use one or more of these features. To provide multiple va

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if date_type is not None:
            query_params['date_type'] = date_type
        if meeting_type is not None:
            query_params['meeting_type'] = meeting_type
        if report_type is not None:
            query_params['report_type'] = report_type
        if search_key is not None:
            query_params['search_key'] = search_key
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if group_id is not None:
            query_params['group_id'] = group_id
        if meeting_feature is not None:
            query_params['meeting_feature'] = meeting_feature

        url = self.base_url + "/report/history_meetings"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed gethistorymeetingandwebinarlist" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute gethistorymeetingandwebinarlist")

    async def report_meetingactivitylogs(
        self,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        meeting_number: str | None = None,
        search_key: str | None = None,
        activity_type: str | None = None
    ) -> ZoomResponse:
        """Get a meeting activities report

        HTTP GET /report/meeting_activities

        Args:
            from_: The start date in 'yyyy-MM-dd'format. The date range defined by the `from` and `to` parameters should only be one month,
            to: The end date 'yyyy-MM-dd' format.
            page_size: The number of records to be returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            meeting_number: The meeting's number.
            search_key: An operator's name or email.
            activity_type: Activity type.  -1 - All activities.  0 - Meeting created.  1 - Meeting started.  2 - User joined.  3 - User left.  4 -

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if meeting_number is not None:
            query_params['meeting_number'] = meeting_number
        if search_key is not None:
            query_params['search_key'] = search_key
        if activity_type is not None:
            query_params['activity_type'] = activity_type

        url = self.base_url + "/report/meeting_activities"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_meetingactivitylogs" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_meetingactivitylogs")

    async def report_meeting_details(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Get meeting detail reports

        HTTP GET /report/meetings/{meetingId}

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API returns a response for the lat

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/report/meetings/{meetingId}".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_meeting_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_meeting_details")

    async def report_meeting_participants(
        self,
        meetingId: str,
        page_size: int | None = None,
        next_page_token: str | None = None,
        include_fields: str | None = None
    ) -> ZoomResponse:
        """Get meeting participant reports

        HTTP GET /report/meetings/{meetingId}/participants

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API will return a response for the
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            include_fields: Provide `registrant_id` as the value for this field if you would like to see the registrant ID attribute in the response

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if include_fields is not None:
            query_params['include_fields'] = include_fields

        url = self.base_url + "/report/meetings/{meetingId}/participants".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_meeting_participants" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_meeting_participants")

    async def report_meeting_polls(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Get meeting poll reports

        HTTP GET /report/meetings/{meetingId}/polls

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API will return a response for the

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/report/meetings/{meetingId}/polls".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_meeting_polls" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_meeting_polls")

    async def report_meeting_qa(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Get meeting Q&A report

        HTTP GET /report/meetings/{meetingId}/qa

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API will return a response for the

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/report/meetings/{meetingId}/qa".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_meeting_qa" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_meeting_qa")

    async def report_meeting_survey(
        self,
        meetingId: str
    ) -> ZoomResponse:
        """Get meeting survey report

        HTTP GET /report/meetings/{meetingId}/survey

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID).  * If you provide a meeting ID, the API will return a response for the

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/report/meetings/{meetingId}/survey".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_meeting_survey" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_meeting_survey")

    async def report_operation_logs(
        self,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        category_type: str | None = None
    ) -> ZoomResponse:
        """Get operation logs report

        HTTP GET /report/operationlogs

        Args:
            from_: Start date in 'yyyy-mm-dd' or 'yyyy-MM-dd HH:mm' format. The date range defined by the `from` and `to` parameters should
            to: End date in 'yyyy-mm-dd' or 'yyyy-MM-dd HH:mm' format.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            category_type: **Optional**     Filter your response by a category type to see reports for a specific category. The value for this fiel

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if category_type is not None:
            query_params['category_type'] = category_type

        url = self.base_url + "/report/operationlogs"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_operation_logs" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_operation_logs")

    async def getremotesupportreport(
        self,
        from_: str | None = None,
        to: str | None = None,
        next_page_token: str | None = None,
        page_size: str | None = None
    ) -> ZoomResponse:
        """Get remote support report

        HTTP GET /report/remote_support

        Args:
            from_: The start date in `yyyy-MM-dd` format. The date range defined by the `from` and `to` parameters should only be one month
            to: The end date in `yyyy-MM-dd` format.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            page_size: The number of records to be returned within a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = page_size

        url = self.base_url + "/report/remote_support"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getremotesupportreport" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getremotesupportreport")

    async def report_telephone(
        self,
        type_: str | None = None,
        query_date_type: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        page_number: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get telephone reports

        HTTP GET /report/telephone

        Args:
            type_: Audio types:    `1` - Toll-free Call-in &amp; Call-out.    `2` - Toll      `3` - SIP Connected Audio
            query_date_type: The type of date to query.  * `start_time` &mdash; Query by call start time.  * `end_time` &mdash; Query by call end tim
            from_: Start date in 'yyyy-mm-dd' format. The date range defined by the &quot;from&quot; and &quot;to&quot; parameters should o
            to: End date.
            page_size: The number of records returned within a single API call.
            page_number: The page number of the current page in the returned records. This field is **not** available if the `query_date_type` pa
            next_page_token: Use the next page token to paginate through large result sets. A next page token will be returned whenever the set of av

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if query_date_type is not None:
            query_params['query_date_type'] = query_date_type
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if page_number is not None:
            query_params['page_number'] = str(page_number)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/report/telephone"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_telephone" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_telephone")

    async def report_upcoming_events(
        self,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        type_: str | None = None,
        group_id: str | None = None
    ) -> ZoomResponse:
        """Get upcoming events report

        HTTP GET /report/upcoming_events

        Args:
            from_: Start date in 'yyyy-mm-dd' format. The date range defined by the &quot;from&quot; and &quot;to&quot; parameters should o
            to: End date.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            type_: The type of event to query.  * `meeting` &mdash; A meeting event.  * `webinar` &mdash; A webinar event.  * `all` &mdash;
            group_id: The group ID. To get a group ID, use the [**List groups**](/api-reference/zoom-api/methods#operation/groups) API.    **N

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if type_ is not None:
            query_params['type'] = type_
        if group_id is not None:
            query_params['group_id'] = group_id

        url = self.base_url + "/report/upcoming_events"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_upcoming_events" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_upcoming_events")

    async def report_users(
        self,
        type_: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        page_number: int | None = None,
        next_page_token: str | None = None,
        group_id: str | None = None
    ) -> ZoomResponse:
        """Get active or inactive host reports

        HTTP GET /report/users

        Args:
            type_: Active or inactive hosts.    `active` - Active hosts.     `inactive` - Inactive hosts.
            from_: Start date in 'yyyy-mm-dd' format. The date range defined by the `from` and `to` parameters should only be one month as
            to: End date.
            page_size: The number of records returned within a single API call.
            page_number: The page number of the current page in the returned records.
            next_page_token: The next page token is used to paginate through large result sets. A next page token will be returned whenever the set o
            group_id: The group ID. To get a group ID, use the [**List groups**](/docs/api/rest/reference/user/methods/#operation/groups) API.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if page_number is not None:
            query_params['page_number'] = str(page_number)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if group_id is not None:
            query_params['group_id'] = group_id

        url = self.base_url + "/report/users"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_users" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_users")

    async def report_meetings(
        self,
        userId: str,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        type_: str | None = None
    ) -> ZoomResponse:
        """Get meeting reports

        HTTP GET /report/users/{userId}/meetings

        Args:
            userId: The user ID or email address of the user. For user-level apps, pass the `me` value.
            from_: Start date in 'yyyy-mm-dd' format. The date range defined by the &quot;from&quot; and &quot;to&quot; parameters should o
            to: End date.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            type_: The meeting type to query for:  * `past` - All past meetings.  * `pastOne` - A single past user meeting.  * `pastJoined`

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if type_ is not None:
            query_params['type'] = type_

        url = self.base_url + "/report/users/{userId}/meetings".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_meetings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_meetings")

    async def report_webinar_details(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """Get webinar detail reports

        HTTP GET /report/webinars/{webinarId}

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API will return a response for the

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/report/webinars/{webinarId}".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_webinar_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_webinar_details")

    async def report_webinar_participants(
        self,
        webinarId: str,
        page_size: int | None = None,
        next_page_token: str | None = None,
        include_fields: str | None = None
    ) -> ZoomResponse:
        """Get webinar participant reports

        HTTP GET /report/webinars/{webinarId}/participants

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API will return a response for the
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            include_fields: The additional query parameters to include.  * `registrant_id` - Include the registrant's ID in the API response. The re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if include_fields is not None:
            query_params['include_fields'] = include_fields

        url = self.base_url + "/report/webinars/{webinarId}/participants".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_webinar_participants" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_webinar_participants")

    async def report_webinar_polls(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """Get webinar poll reports

        HTTP GET /report/webinars/{webinarId}/polls

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API will return a response for the

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/report/webinars/{webinarId}/polls".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_webinar_polls" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_webinar_polls")

    async def report_webinar_qa(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """Get webinar Q&A report

        HTTP GET /report/webinars/{webinarId}/qa

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API will return a response for the

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/report/webinars/{webinarId}/qa".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_webinar_qa" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_webinar_qa")

    async def report_webinar_survey(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """Get webinar survey report

        HTTP GET /report/webinars/{webinarId}/survey

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API returns a response for the lat

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/report/webinars/{webinarId}/survey".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_webinar_survey" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_webinar_survey")

    async def list_sip_phone_phones(
        self,
        search_key: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List SIP phones

        HTTP GET /sip_phones/phones

        Args:
            search_key: A user's user name or email address. If this parameter is provided, only the SIP phone system integration enabled for th
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token will be returned whenever the set of av

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if search_key is not None:
            query_params['search_key'] = search_key
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/sip_phones/phones"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_sip_phone_phones" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_sip_phone_phones")

    async def enable_sip_phone_phones(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Enable SIP phone

        HTTP POST /sip_phones/phones

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/sip_phones/phones"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed enable_sip_phone_phones" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute enable_sip_phone_phones")

    async def delete_sip_phone_phones(
        self,
        phoneId: str
    ) -> ZoomResponse:
        """Delete SIP phone

        HTTP DELETE /sip_phones/phones/{phoneId}

        Args:
            phoneId: The SIP phone ID. It can be retrieved from the **List SIP phones** API.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/sip_phones/phones/{phoneId}".format(phoneId=phoneId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_sip_phone_phones" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_sip_phone_phones")

    async def update_sip_phone_phones(
        self,
        phoneId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update SIP phone

        HTTP PATCH /sip_phones/phones/{phoneId}

        Args:
            phoneId: The SIP phone ID. Retrieve this with the **List SIP phones** API.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/sip_phones/phones/{phoneId}".format(phoneId=phoneId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_sip_phone_phones" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_sip_phone_phones")

    async def tsp(
        self
    ) -> ZoomResponse:
        """Get account's TSP information

        HTTP GET /tsp

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/tsp"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed tsp" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute tsp")

    async def tsp_update(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update an account's TSP information

        HTTP PATCH /tsp

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/tsp"

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed tsp_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute tsp_update")

    async def user_ts_ps(
        self,
        userId: str
    ) -> ZoomResponse:
        """List user's TSP accounts

        HTTP GET /users/{userId}/tsp

        Args:
            userId: The user ID or email address of the user. For user-level apps, pass the `me` value.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/tsp".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_ts_ps" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_ts_ps")

    async def user_tsp_create(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a user's TSP account

        HTTP POST /users/{userId}/tsp

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/tsp".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_tsp_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_tsp_create")

    async def tsp_url_update(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Set global dial-in URL for a TSP user

        HTTP PATCH /users/{userId}/tsp/settings

        Args:
            userId: The user's user ID or email address.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/tsp/settings".format(userId=userId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed tsp_url_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute tsp_url_update")

    async def user_tsp(
        self,
        userId: str,
        tspId: str
    ) -> ZoomResponse:
        """Get a user's TSP account

        HTTP GET /users/{userId}/tsp/{tspId}

        Args:
            userId: The user ID or email address of the user. For user-level apps, pass the `me` value.
            tspId: TSP account ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/tsp/{tspId}".format(userId=userId, tspId=tspId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_tsp" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_tsp")

    async def user_tsp_delete(
        self,
        userId: str,
        tspId: str
    ) -> ZoomResponse:
        """Delete a user's TSP account

        HTTP DELETE /users/{userId}/tsp/{tspId}

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            tspId: TSP account ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/tsp/{tspId}".format(userId=userId, tspId=tspId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_tsp_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_tsp_delete")

    async def user_tsp_update(
        self,
        userId: str,
        tspId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a TSP account

        HTTP PATCH /users/{userId}/tsp/{tspId}

        Args:
            userId: The user ID or email address of the user. For user-level apps, pass the `me` value.
            tspId: TSP account ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/tsp/{tspId}".format(userId=userId, tspId=tspId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_tsp_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_tsp_update")

    async def trackingfield_list(
        self
    ) -> ZoomResponse:
        """List tracking fields

        HTTP GET /tracking_fields

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/tracking_fields"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed trackingfield_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute trackingfield_list")

    async def trackingfield_create(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a tracking field

        HTTP POST /tracking_fields

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/tracking_fields"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed trackingfield_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute trackingfield_create")

    async def trackingfield_get(
        self,
        fieldId: str
    ) -> ZoomResponse:
        """Get a tracking field

        HTTP GET /tracking_fields/{fieldId}

        Args:
            fieldId: The tracking field ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/tracking_fields/{fieldId}".format(fieldId=fieldId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed trackingfield_get" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute trackingfield_get")

    async def trackingfield_delete(
        self,
        fieldId: str
    ) -> ZoomResponse:
        """Delete a tracking field

        HTTP DELETE /tracking_fields/{fieldId}

        Args:
            fieldId: The tracking field ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/tracking_fields/{fieldId}".format(fieldId=fieldId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed trackingfield_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute trackingfield_delete")

    async def trackingfield_update(
        self,
        fieldId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a tracking field

        HTTP PATCH /tracking_fields/{fieldId}

        Args:
            fieldId: The tracking field ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/tracking_fields/{fieldId}".format(fieldId=fieldId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed trackingfield_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute trackingfield_update")

    async def delete_webinar_chat_message_by_id(
        self,
        webinarId: str,
        messageId: str,
        file_ids: str | None = None
    ) -> ZoomResponse:
        """Delete a live webinar message

        HTTP DELETE /live_webinars/{webinarId}/chat/messages/{messageId}

        Args:
            webinarId: The webinar's ID.
            messageId: The live webinar chat message's unique identifier (UUID), in base64-encoded format.
            file_ids: The live webinar chat file's universally unique identifier (UUID), in base64-encoded format. Separate multiple values wi

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if file_ids is not None:
            query_params['file_ids'] = file_ids

        url = self.base_url + "/live_webinars/{webinarId}/chat/messages/{messageId}".format(webinarId=webinarId, messageId=messageId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_webinar_chat_message_by_id" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_webinar_chat_message_by_id")

    async def webinar_absentees(
        self,
        webinarId: str,
        occurrence_id: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get webinar absentees

        HTTP GET /past_webinars/{webinarId}/absentees

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API will return a response for the
            occurrence_id: The meeting or webinar occurrence ID.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_id is not None:
            query_params['occurrence_id'] = occurrence_id
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/past_webinars/{webinarId}/absentees".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_absentees" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_absentees")

    async def past_webinars(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """List past webinar instances

        HTTP GET /past_webinars/{webinarId}/instances

        Args:
            webinarId: The webinar's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/past_webinars/{webinarId}/instances".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed past_webinars" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute past_webinars")

    async def list_webinar_participants(
        self,
        webinarId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List webinar participants

        HTTP GET /past_webinars/{webinarId}/participants

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API returns a response for the lat
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/past_webinars/{webinarId}/participants".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_webinar_participants" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_webinar_participants")

    async def list_past_webinar_poll_results(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """List past webinar poll results

        HTTP GET /past_webinars/{webinarId}/polls

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API returns a response for the lat

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/past_webinars/{webinarId}/polls".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_past_webinar_poll_results" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_past_webinar_poll_results")

    async def list_past_webinar_qa(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """List Q&As of a past webinar

        HTTP GET /past_webinars/{webinarId}/qa

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).  * If you provide a webinar ID, the API returns a response for the lat

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/past_webinars/{webinarId}/qa".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_past_webinar_qa" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_past_webinar_qa")

    async def list_webinar_templates(
        self,
        userId: str
    ) -> ZoomResponse:
        """List webinar templates

        HTTP GET /users/{userId}/webinar_templates

        Args:
            userId: The user's ID. To get a user's ID, use the [**List users**](/docs/api-reference/zoom-api/ma#operation/users) API. For us

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/webinar_templates".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_webinar_templates" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_webinar_templates")

    async def webinar_template_create(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a webinar template

        HTTP POST /users/{userId}/webinar_templates

        Args:
            userId: The user ID retrievable from the [List users](/api-reference/zoom-api/methods#operation/users) API.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/webinar_templates".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_template_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_template_create")

    async def webinars(
        self,
        userId: str,
        type_: str | None = None,
        page_size: int | None = None,
        page_number: int | None = None
    ) -> ZoomResponse:
        """List webinars

        HTTP GET /users/{userId}/webinars

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            type_: The type of webinar.  * `scheduled` - All valid previous (unexpired) webinars, live webinars, and upcoming scheduled web
            page_size: The number of records returned within a single API call.
            page_number: **Deprecated** We will no longer support this field in a future release. Instead, use the `next_page_token` for paginati

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if page_number is not None:
            query_params['page_number'] = str(page_number)

        url = self.base_url + "/users/{userId}/webinars".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinars" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinars")

    async def webinar_create(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a webinar

        HTTP POST /users/{userId}/webinars

        Args:
            userId: The user ID or email address of the user. For user-level apps, pass the `me` value.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/webinars".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_create")

    async def webinar(
        self,
        webinarId: str,
        *,
        occurrence_id: str | None = None,
        show_previous_occurrences: bool | None = None
    ) -> ZoomResponse:
        """Get a webinar

        HTTP GET /webinars/{webinarId}

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID).
            occurrence_id: Unique identifier for an occurrence of a recurring webinar. [Recurring webinars](https://support.zoom.us/hc/en-us/articl
            show_previous_occurrences: Set the value of this field to `true` to view webinar details of all previous occurrences of a recurring webinar.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_id is not None:
            query_params['occurrence_id'] = occurrence_id
        if show_previous_occurrences is not None:
            query_params['show_previous_occurrences'] = str(show_previous_occurrences).lower()

        url = self.base_url + "/webinars/{webinarId}".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar")

    async def webinar_delete(
        self,
        webinarId: str,
        *,
        occurrence_id: str | None = None,
        cancel_webinar_reminder: bool | None = None
    ) -> ZoomResponse:
        """Delete a webinar

        HTTP DELETE /webinars/{webinarId}

        Args:
            webinarId: The webinar's ID.
            occurrence_id: The meeting or webinar occurrence ID.
            cancel_webinar_reminder: `true` - Notify panelists and registrants about the webinar cancellation via email.   `false` - Do not send any email no

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_id is not None:
            query_params['occurrence_id'] = occurrence_id
        if cancel_webinar_reminder is not None:
            query_params['cancel_webinar_reminder'] = str(cancel_webinar_reminder).lower()

        url = self.base_url + "/webinars/{webinarId}".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_delete")

    async def webinar_update(
        self,
        webinarId: str,
        body: dict[str, Any],
        occurrence_id: str | None = None
    ) -> ZoomResponse:
        """Update a webinar

        HTTP PATCH /webinars/{webinarId}

        Args:
            webinarId: The webinar's ID.
            body: Request body payload
            occurrence_id: Webinar occurrence ID. Support change of agenda, start time, duration, and settings `host_video`, `panelist_video`, `hd_

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_id is not None:
            query_params['occurrence_id'] = occurrence_id

        url = self.base_url + "/webinars/{webinarId}".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_update")

    async def add_batch_webinar_registrants(
        self,
        webinarId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Perform batch registration

        HTTP POST /webinars/{webinarId}/batch_registrants

        Args:
            webinarId: The webinar's unique identifier.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/batch_registrants".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_batch_webinar_registrants" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_batch_webinar_registrants")

    async def get_webinar_branding(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """Get webinar's session branding

        HTTP GET /webinars/{webinarId}/branding

        Args:
            webinarId: The webinar's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/branding".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_webinar_branding" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_webinar_branding")

    async def create_webinar_branding_name_tag(
        self,
        webinarId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a webinar's branding name tag

        HTTP POST /webinars/{webinarId}/branding/name_tags

        Args:
            webinarId: The webinar's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/branding/name_tags".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_webinar_branding_name_tag" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_webinar_branding_name_tag")

    async def delete_webinar_branding_name_tag(
        self,
        webinarId: str,
        name_tag_ids: str | None = None
    ) -> ZoomResponse:
        """Delete a webinar's branding name tag

        HTTP DELETE /webinars/{webinarId}/branding/name_tags

        Args:
            webinarId: The webinar's ID.
            name_tag_ids: A comma-separated list of the name tag IDs to delete.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if name_tag_ids is not None:
            query_params['name_tag_ids'] = name_tag_ids

        url = self.base_url + "/webinars/{webinarId}/branding/name_tags".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_webinar_branding_name_tag" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_webinar_branding_name_tag")

    async def update_webinar_branding_name_tag(
        self,
        webinarId: str,
        nameTagId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a webinar's branding name tag

        HTTP PATCH /webinars/{webinarId}/branding/name_tags/{nameTagId}

        Args:
            webinarId: The webinar's ID.
            nameTagId: The name tag's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/branding/name_tags/{nameTagId}".format(webinarId=webinarId, nameTagId=nameTagId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_webinar_branding_name_tag" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_webinar_branding_name_tag")

    async def upload_webinar_branding_vb(
        self,
        webinarId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Upload a webinar's branding virtual background

        HTTP POST /webinars/{webinarId}/branding/virtual_backgrounds

        Args:
            webinarId: The webinar's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/branding/virtual_backgrounds".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed upload_webinar_branding_vb" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute upload_webinar_branding_vb")

    async def delete_webinar_branding_vb(
        self,
        webinarId: str,
        ids: str | None = None
    ) -> ZoomResponse:
        """Delete a webinar's branding virtual backgrounds

        HTTP DELETE /webinars/{webinarId}/branding/virtual_backgrounds

        Args:
            webinarId: The webinar's ID.
            ids: A comma-separated list of the virtual background file IDs to delete.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if ids is not None:
            query_params['ids'] = ids

        url = self.base_url + "/webinars/{webinarId}/branding/virtual_backgrounds".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_webinar_branding_vb" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_webinar_branding_vb")

    async def set_webinar_branding_vb(
        self,
        webinarId: str,
        *,
        id_: str | None = None,
        set_default_for_all_panelists: bool | None = None
    ) -> ZoomResponse:
        """Set webinar's default branding virtual background

        HTTP PATCH /webinars/{webinarId}/branding/virtual_backgrounds

        Args:
            webinarId: The webinar's ID.
            id_: The virtual background file ID to update.
            set_default_for_all_panelists: Whether to set the virtual background file as the new default for all panelists. This includes panelists not currently a

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if id_ is not None:
            query_params['id'] = id_
        if set_default_for_all_panelists is not None:
            query_params['set_default_for_all_panelists'] = str(set_default_for_all_panelists).lower()

        url = self.base_url + "/webinars/{webinarId}/branding/virtual_backgrounds".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed set_webinar_branding_vb" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute set_webinar_branding_vb")

    async def upload_webinar_branding_wallpaper(
        self,
        webinarId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Upload a webinar's branding wallpaper

        HTTP POST /webinars/{webinarId}/branding/wallpaper

        Args:
            webinarId: The webinar's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/branding/wallpaper".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed upload_webinar_branding_wallpaper" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute upload_webinar_branding_wallpaper")

    async def delete_webinar_branding_wallpaper(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """Delete a webinar's branding wallpaper

        HTTP DELETE /webinars/{webinarId}/branding/wallpaper

        Args:
            webinarId: The webinar's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/branding/wallpaper".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_webinar_branding_wallpaper" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_webinar_branding_wallpaper")

    async def webinar_invite_links_create(
        self,
        webinarId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create webinar's invite links

        HTTP POST /webinars/{webinarId}/invite_links

        Args:
            webinarId: The webinar's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/invite_links".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_invite_links_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_invite_links_create")

    async def webinar_live_streaming_join_token(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """Get a webinar's join token for live streaming

        HTTP GET /webinars/{webinarId}/jointoken/live_streaming

        Args:
            webinarId: The webinar's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/jointoken/live_streaming".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_live_streaming_join_token" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_live_streaming_join_token")

    async def webinar_local_archiving_archive_token(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """Get a webinar's archive token for local archiving

        HTTP GET /webinars/{webinarId}/jointoken/local_archiving

        Args:
            webinarId: The webinar's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/jointoken/local_archiving".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_local_archiving_archive_token" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_local_archiving_archive_token")

    async def webinar_local_recording_join_token(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """Get a webinar's join token for local recording

        HTTP GET /webinars/{webinarId}/jointoken/local_recording

        Args:
            webinarId: The webinar's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/jointoken/local_recording".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_local_recording_join_token" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_local_recording_join_token")

    async def get_webinar_live_stream_details(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """Get live stream details

        HTTP GET /webinars/{webinarId}/livestream

        Args:
            webinarId: The webinar's unique ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/livestream".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_webinar_live_stream_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_webinar_live_stream_details")

    async def webinar_live_stream_update(
        self,
        webinarId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a live stream

        HTTP PATCH /webinars/{webinarId}/livestream

        Args:
            webinarId: The webinar's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/livestream".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_live_stream_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_live_stream_update")

    async def webinar_live_stream_status_update(
        self,
        webinarId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update live stream status

        HTTP PATCH /webinars/{webinarId}/livestream/status

        Args:
            webinarId: The webinar's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/livestream/status".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_live_stream_status_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_live_stream_status_update")

    async def webinar_panelists(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """List panelists

        HTTP GET /webinars/{webinarId}/panelists

        Args:
            webinarId: The webinar's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/panelists".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_panelists" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_panelists")

    async def webinar_panelist_create(
        self,
        webinarId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add panelists

        HTTP POST /webinars/{webinarId}/panelists

        Args:
            webinarId: The webinar's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/panelists".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_panelist_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_panelist_create")

    async def webinar_panelists_delete(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """Remove all panelists

        HTTP DELETE /webinars/{webinarId}/panelists

        Args:
            webinarId: The webinar's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/panelists".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_panelists_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_panelists_delete")

    async def webinar_panelist_delete(
        self,
        webinarId: str,
        panelistId: str
    ) -> ZoomResponse:
        """Remove a panelist

        HTTP DELETE /webinars/{webinarId}/panelists/{panelistId}

        Args:
            webinarId: The webinar's ID.
            panelistId: The panelist's ID or email.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/panelists/{panelistId}".format(webinarId=webinarId, panelistId=panelistId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_panelist_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_panelist_delete")

    async def webinar_polls(
        self,
        webinarId: str,
        *,
        anonymous: bool | None = None
    ) -> ZoomResponse:
        """List a webinar's polls

        HTTP GET /webinars/{webinarId}/polls

        Args:
            webinarId: The webinar's ID.
            anonymous: Whether to query for polls with the **Anonymous** option enabled:  * `true` &mdash; Query for polls with the **Anonymous

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if anonymous is not None:
            query_params['anonymous'] = str(anonymous).lower()

        url = self.base_url + "/webinars/{webinarId}/polls".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_polls" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_polls")

    async def webinar_poll_create(
        self,
        webinarId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a webinar's poll

        HTTP POST /webinars/{webinarId}/polls

        Args:
            webinarId: The webinar's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/polls".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_poll_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_poll_create")

    async def webinar_poll_get(
        self,
        webinarId: str,
        pollId: str
    ) -> ZoomResponse:
        """Get a webinar poll

        HTTP GET /webinars/{webinarId}/polls/{pollId}

        Args:
            webinarId: The webinar's ID.
            pollId: The poll ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/polls/{pollId}".format(webinarId=webinarId, pollId=pollId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_poll_get" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_poll_get")

    async def webinar_poll_update(
        self,
        webinarId: str,
        pollId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a webinar poll

        HTTP PUT /webinars/{webinarId}/polls/{pollId}

        Args:
            webinarId: The webinar's ID.
            pollId: The poll ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/polls/{pollId}".format(webinarId=webinarId, pollId=pollId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_poll_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_poll_update")

    async def webinar_poll_delete(
        self,
        webinarId: str,
        pollId: str
    ) -> ZoomResponse:
        """Delete a webinar poll

        HTTP DELETE /webinars/{webinarId}/polls/{pollId}

        Args:
            webinarId: The webinar's ID.
            pollId: The poll ID

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/polls/{pollId}".format(webinarId=webinarId, pollId=pollId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_poll_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_poll_delete")

    async def webinar_registrants(
        self,
        webinarId: str,
        occurrence_id: str | None = None,
        status: str | None = None,
        tracking_source_id: str | None = None,
        page_size: int | None = None,
        page_number: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List webinar registrants

        HTTP GET /webinars/{webinarId}/registrants

        Args:
            webinarId: The webinar's ID.
            occurrence_id: The meeting or webinar occurrence ID.
            status: Query by the registrant's status.  * `pending` - The registration is pending.  * `approved` - The registrant is approved
            tracking_source_id: The tracking source ID for the registrants. Useful if you share the webinar registration page in multiple locations. See
            page_size: The number of records returned within a single API call.
            page_number: **Deprecated** This field will be deprecated. We will no longer support this field in a future release. Instead, use the
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_id is not None:
            query_params['occurrence_id'] = occurrence_id
        if status is not None:
            query_params['status'] = status
        if tracking_source_id is not None:
            query_params['tracking_source_id'] = tracking_source_id
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if page_number is not None:
            query_params['page_number'] = str(page_number)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/webinars/{webinarId}/registrants".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_registrants" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_registrants")

    async def webinar_registrant_create(
        self,
        webinarId: str,
        body: dict[str, Any],
        occurrence_ids: str | None = None
    ) -> ZoomResponse:
        """Add a webinar registrant

        HTTP POST /webinars/{webinarId}/registrants

        Args:
            webinarId: The webinar's ID.
            body: Request body payload
            occurrence_ids: A comma-separated list of webinar occurrence IDs. Get this value with the [Get a webinar](/docs/api/rest/reference/zoom-

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_ids is not None:
            query_params['occurrence_ids'] = occurrence_ids

        url = self.base_url + "/webinars/{webinarId}/registrants".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_registrant_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_registrant_create")

    async def webinar_registrants_questions_get(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """List registration questions

        HTTP GET /webinars/{webinarId}/registrants/questions

        Args:
            webinarId: The webinar's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/registrants/questions".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_registrants_questions_get" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_registrants_questions_get")

    async def webinar_registrant_question_update(
        self,
        webinarId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update registration questions

        HTTP PATCH /webinars/{webinarId}/registrants/questions

        Args:
            webinarId: The webinar's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/registrants/questions".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_registrant_question_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_registrant_question_update")

    async def webinar_registrant_status(
        self,
        webinarId: str,
        body: dict[str, Any],
        occurrence_id: str | None = None
    ) -> ZoomResponse:
        """Update registrant's status

        HTTP PUT /webinars/{webinarId}/registrants/status

        Args:
            webinarId: The webinar's ID.
            body: Request body payload
            occurrence_id: The meeting or webinar occurrence ID.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_id is not None:
            query_params['occurrence_id'] = occurrence_id

        url = self.base_url + "/webinars/{webinarId}/registrants/status".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_registrant_status" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_registrant_status")

    async def webinar_registrant_get(
        self,
        webinarId: str,
        registrantId: str,
        occurrence_id: str | None = None
    ) -> ZoomResponse:
        """Get a webinar registrant

        HTTP GET /webinars/{webinarId}/registrants/{registrantId}

        Args:
            webinarId: The webinar's ID.
            registrantId: The registrant ID.
            occurrence_id: The meeting or webinar occurrence ID.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_id is not None:
            query_params['occurrence_id'] = occurrence_id

        url = self.base_url + "/webinars/{webinarId}/registrants/{registrantId}".format(webinarId=webinarId, registrantId=registrantId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_registrant_get" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_registrant_get")

    async def delete_webinar_registrant(
        self,
        webinarId: str,
        registrantId: str,
        occurrence_id: str | None = None
    ) -> ZoomResponse:
        """Delete a webinar registrant

        HTTP DELETE /webinars/{webinarId}/registrants/{registrantId}

        Args:
            webinarId: The webinar ID.
            registrantId: The registrant ID.
            occurrence_id: The webinar occurrence ID.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if occurrence_id is not None:
            query_params['occurrence_id'] = occurrence_id

        url = self.base_url + "/webinars/{webinarId}/registrants/{registrantId}".format(webinarId=webinarId, registrantId=registrantId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_webinar_registrant" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_webinar_registrant")

    async def get_webinar_sip_dialing_with_passcode(
        self,
        webinarId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Get a webinar SIP URI with passcode

        HTTP POST /webinars/{webinarId}/sip_dialing

        Args:
            webinarId: The webinar's ID.    When storing this value in your database, store it as a long format integer and **not** an integer.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/sip_dialing".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_webinar_sip_dialing_with_passcode" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_webinar_sip_dialing_with_passcode")

    async def webinar_status(
        self,
        webinarId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update webinar status

        HTTP PUT /webinars/{webinarId}/status

        Args:
            webinarId: The webinar's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/status".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_status" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_status")

    async def webinar_survey_get(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """Get a webinar survey

        HTTP GET /webinars/{webinarId}/survey

        Args:
            webinarId: The webinar's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/survey".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_survey_get" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_survey_get")

    async def webinar_survey_delete(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """Delete a webinar survey

        HTTP DELETE /webinars/{webinarId}/survey

        Args:
            webinarId: The webinar's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/survey".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_survey_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_survey_delete")

    async def webinar_survey_update(
        self,
        webinarId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a webinar survey

        HTTP PATCH /webinars/{webinarId}/survey

        Args:
            webinarId: The webinar's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/survey".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_survey_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_survey_update")

    async def webinar_token(
        self,
        webinarId: str,
        type_: str | None = None
    ) -> ZoomResponse:
        """Get webinar's token

        HTTP GET /webinars/{webinarId}/token

        Args:
            webinarId: The webinar's ID.
            type_: The webinar token type:  * `closed_caption_token` &mdash; The third-party closed caption API token.   This defaults to `

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_

        url = self.base_url + "/webinars/{webinarId}/token".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed webinar_token" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute webinar_token")

    async def get_tracking_sources(
        self,
        webinarId: str
    ) -> ZoomResponse:
        """Get webinar tracking sources

        HTTP GET /webinars/{webinarId}/tracking_sources

        Args:
            webinarId: The webinar's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/webinars/{webinarId}/tracking_sources".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_tracking_sources" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_tracking_sources")

    async def list_zoom_phone_account_settings(
        self,
        setting_types: str | None = None
    ) -> ZoomResponse:
        """List an account's Zoom phone settings

        HTTP GET /phone/account_settings

        Args:
            setting_types: The comma separated list of the setting items you want to fetch. Allowed values: `call_live_transcription`,`local_surviv

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if setting_types is not None:
            query_params['setting_types'] = setting_types

        url = self.base_url + "/phone/account_settings"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_zoom_phone_account_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_zoom_phone_account_settings")

    async def list_customize_outbound_caller_numbers(
        self,
        *,
        selected: bool | None = None,
        site_id: str | None = None,
        extension_type: str | None = None,
        keyword: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List an account's customized outbound caller ID phone numbers

        HTTP GET /phone/outbound_caller_id/customized_numbers

        Args:
            selected: The status of the phone numbers.     `true`- Numbers already added to the custom list.      `false`- Numbers not yet add
            site_id: This field filters phone numbers that belong to the site.
            extension_type: The type of extension to which the phone number belongs.
            keyword: A search keyword for phone or extension numbers.
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if selected is not None:
            query_params['selected'] = str(selected).lower()
        if site_id is not None:
            query_params['site_id'] = site_id
        if extension_type is not None:
            query_params['extension_type'] = extension_type
        if keyword is not None:
            query_params['keyword'] = keyword
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/outbound_caller_id/customized_numbers"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_customize_outbound_caller_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_customize_outbound_caller_numbers")

    async def add_outbound_caller_numbers(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add phone numbers for an account's customized outbound caller ID

        HTTP POST /phone/outbound_caller_id/customized_numbers

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/outbound_caller_id/customized_numbers"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_outbound_caller_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_outbound_caller_numbers")

    async def delete_outbound_caller_numbers(
        self,
        customize_ids: list[object] | None = None
    ) -> ZoomResponse:
        """Delete phone numbers for an account's customized outbound caller ID

        HTTP DELETE /phone/outbound_caller_id/customized_numbers

        Args:
            customize_ids: The customization IDs.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if customize_ids is not None:
            query_params['customize_ids'] = customize_ids

        url = self.base_url + "/phone/outbound_caller_id/customized_numbers"

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_outbound_caller_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_outbound_caller_numbers")

    async def list_alert_settings_with_paging_query(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        module: int | None = None,
        rule: int | None = None,
        status: int | None = None
    ) -> ZoomResponse:
        """List alert settings with paging query

        HTTP GET /phone/alert_settings

        Args:
            page_size: The number of records a single API call returns.
            next_page_token: The current page number of the returned records.
            module: This field filters the specific alert list by the module. The module and its code mappings are shown as:     `Call Queue
            rule: This field filters the specific alert list by the rule. The rule and its code mappings display as:     `Service Level`-`
            status: The alert's status: * `0` &mdash; Inactive. * `1` &mdash; Active.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if module is not None:
            query_params['module'] = str(module)
        if rule is not None:
            query_params['rule'] = str(rule)
        if status is not None:
            query_params['status'] = str(status)

        url = self.base_url + "/phone/alert_settings"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_alert_settings_with_paging_query" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_alert_settings_with_paging_query")

    async def add_an_alert_setting(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add an alert setting

        HTTP POST /phone/alert_settings

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/alert_settings"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_an_alert_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_an_alert_setting")

    async def get_alert_setting_details(
        self,
        alertSettingId: str
    ) -> ZoomResponse:
        """Get alert setting details

        HTTP GET /phone/alert_settings/{alertSettingId}

        Args:
            alertSettingId: The unique Identifier of the alert setting.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/alert_settings/{alertSettingId}".format(alertSettingId=alertSettingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_alert_setting_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_alert_setting_details")

    async def delete_an_alert_setting(
        self,
        alertSettingId: str
    ) -> ZoomResponse:
        """Delete an alert setting

        HTTP DELETE /phone/alert_settings/{alertSettingId}

        Args:
            alertSettingId: The alert setting ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/alert_settings/{alertSettingId}".format(alertSettingId=alertSettingId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_an_alert_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_an_alert_setting")

    async def update_an_alert_setting(
        self,
        alertSettingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update an alert setting

        HTTP PATCH /phone/alert_settings/{alertSettingId}

        Args:
            alertSettingId: The alert setting ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/alert_settings/{alertSettingId}".format(alertSettingId=alertSettingId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_an_alert_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_an_alert_setting")

    async def get_audio_item(
        self,
        audioId: str
    ) -> ZoomResponse:
        """Get an audio item

        HTTP GET /phone/audios/{audioId}

        Args:
            audioId: The unique identifier of the audio item.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/audios/{audioId}".format(audioId=audioId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_audio_item" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_audio_item")

    async def delete_audio_item(
        self,
        audioId: str
    ) -> ZoomResponse:
        """Delete an audio item

        HTTP DELETE /phone/audios/{audioId}

        Args:
            audioId: Unique identifier of the audio item.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/audios/{audioId}".format(audioId=audioId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_audio_item" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_audio_item")

    async def update_audio_item(
        self,
        audioId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update an audio item

        HTTP PATCH /phone/audios/{audioId}

        Args:
            audioId: Unique identifier of the audio item.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/audios/{audioId}".format(audioId=audioId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_audio_item" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_audio_item")

    async def list_audio_items(
        self,
        userId: str
    ) -> ZoomResponse:
        """List audio items

        HTTP GET /phone/users/{userId}/audios

        Args:
            userId: Path parameter

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/audios".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_audio_items" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_audio_items")

    async def add_an_audio(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add an audio item for text-to-speech conversion

        HTTP POST /phone/users/{userId}/audios

        Args:
            userId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/audios".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_an_audio" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_an_audio")

    async def add_audio_item(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add audio items

        HTTP POST /phone/users/{userId}/audios/batch

        Args:
            userId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/audios/batch".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_audio_item" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_audio_item")

    async def list_auto_receptionists(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List auto receptionists

        HTTP GET /phone/auto_receptionists

        Args:
            page_size: The total number of records returned from a single API call.
            next_page_token: The next page token is used to paginate through large result sets. A next page token will be returned whenever the set o

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/auto_receptionists"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_auto_receptionists" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_auto_receptionists")

    async def add_auto_receptionist(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add an auto receptionist

        HTTP POST /phone/auto_receptionists

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/auto_receptionists"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_auto_receptionist" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_auto_receptionist")

    async def get_auto_receptionist_detail(
        self,
        autoReceptionistId: str
    ) -> ZoomResponse:
        """Get an auto receptionist

        HTTP GET /phone/auto_receptionists/{autoReceptionistId}

        Args:
            autoReceptionistId: Path parameter

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/auto_receptionists/{autoReceptionistId}".format(autoReceptionistId=autoReceptionistId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_auto_receptionist_detail" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_auto_receptionist_detail")

    async def delete_auto_receptionist(
        self,
        autoReceptionistId: str
    ) -> ZoomResponse:
        """Delete a non-primary auto receptionist

        HTTP DELETE /phone/auto_receptionists/{autoReceptionistId}

        Args:
            autoReceptionistId: The unique identifier of the auto receptionist. It can be retrieved from the [List auto receptionists API](https://marke

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/auto_receptionists/{autoReceptionistId}".format(autoReceptionistId=autoReceptionistId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_auto_receptionist" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_auto_receptionist")

    async def update_auto_receptionist(
        self,
        autoReceptionistId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update an auto receptionist

        HTTP PATCH /phone/auto_receptionists/{autoReceptionistId}

        Args:
            autoReceptionistId: The unique identifier of the auto receptionist. It can be retrieved from the [List auto receptionists API](https://marke
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/auto_receptionists/{autoReceptionistId}".format(autoReceptionistId=autoReceptionistId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_auto_receptionist" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_auto_receptionist")

    async def assign_phone_numbers_auto_receptionist(
        self,
        autoReceptionistId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign phone numbers

        HTTP POST /phone/auto_receptionists/{autoReceptionistId}/phone_numbers

        Args:
            autoReceptionistId: The unique identifier of the auto receptionist. It can be retrieved from the [List auto receptionists API](https://marke
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/auto_receptionists/{autoReceptionistId}/phone_numbers".format(autoReceptionistId=autoReceptionistId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assign_phone_numbers_auto_receptionist" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assign_phone_numbers_auto_receptionist")

    async def unassign_all_phone_nums_auto_receptionist(
        self,
        autoReceptionistId: str
    ) -> ZoomResponse:
        """Unassign all phone numbers

        HTTP DELETE /phone/auto_receptionists/{autoReceptionistId}/phone_numbers

        Args:
            autoReceptionistId: Path parameter

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/auto_receptionists/{autoReceptionistId}/phone_numbers".format(autoReceptionistId=autoReceptionistId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed unassign_all_phone_nums_auto_receptionist" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute unassign_all_phone_nums_auto_receptionist")

    async def unassign_a_phone_num_auto_receptionist(
        self,
        autoReceptionistId: str,
        phoneNumberId: str
    ) -> ZoomResponse:
        """Unassign a phone number

        HTTP DELETE /phone/auto_receptionists/{autoReceptionistId}/phone_numbers/{phoneNumberId}

        Args:
            autoReceptionistId: The unique identifier of the auto receptionist. It can be retrieved from the [List auto receptionists API](https://marke
            phoneNumberId: Unique Identifier of the phone number or provide the actual phone number in e164 format (example: +19995550123).

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/auto_receptionists/{autoReceptionistId}/phone_numbers/{phoneNumberId}".format(autoReceptionistId=autoReceptionistId, phoneNumberId=phoneNumberId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed unassign_a_phone_num_auto_receptionist" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute unassign_a_phone_num_auto_receptionist")

    async def get_auto_receptionists_policy(
        self,
        autoReceptionistId: str
    ) -> ZoomResponse:
        """Get an auto receptionist policy

        HTTP GET /phone/auto_receptionists/{autoReceptionistId}/policies

        Args:
            autoReceptionistId: The unique identifier of the auto receptionist. It can be retrieved from the [List auto receptionists API](https://marke

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/auto_receptionists/{autoReceptionistId}/policies".format(autoReceptionistId=autoReceptionistId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_auto_receptionists_policy" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_auto_receptionists_policy")

    async def update_auto_receptionist_policy(
        self,
        autoReceptionistId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update an auto receptionist policy

        HTTP PATCH /phone/auto_receptionists/{autoReceptionistId}/policies

        Args:
            autoReceptionistId: The unique identifier of the auto receptionist. It can be retrieved from the [List auto receptionists API](https://marke
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/auto_receptionists/{autoReceptionistId}/policies".format(autoReceptionistId=autoReceptionistId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_auto_receptionist_policy" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_auto_receptionist_policy")

    async def add_policy(
        self,
        autoReceptionistId: str,
        policyType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a policy subsetting

        HTTP POST /phone/auto_receptionists/{autoReceptionistId}/policies/{policyType}

        Args:
            autoReceptionistId: The unique identifier of the auto receptionist. It can be retrieved from the [List auto receptionists API](https://marke
            policyType: Corresponds to the policy item you wish to add. Allowed values: `voice_mail`
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/auto_receptionists/{autoReceptionistId}/policies/{policyType}".format(autoReceptionistId=autoReceptionistId, policyType=policyType)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_policy" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_policy")

    async def delete_policy(
        self,
        autoReceptionistId: str,
        policyType: str,
        shared_ids: list[object] | None = None
    ) -> ZoomResponse:
        """Delete a policy subsetting

        HTTP DELETE /phone/auto_receptionists/{autoReceptionistId}/policies/{policyType}

        Args:
            autoReceptionistId: The unique identifier of the auto receptionist. It can be retrieved from the [List auto receptionists](https://developer
            policyType: This field corresponds to the policy item you wish to remove.   Allowed values: `voice_mail`
            shared_ids: The unique identifier of the voicemail that the user can access. It's required only for `voice_mail` policy type.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if shared_ids is not None:
            query_params['shared_ids'] = shared_ids

        url = self.base_url + "/phone/auto_receptionists/{autoReceptionistId}/policies/{policyType}".format(autoReceptionistId=autoReceptionistId, policyType=policyType)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_policy" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_policy")

    async def update_policy(
        self,
        autoReceptionistId: str,
        policyType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a policy subsetting

        HTTP PATCH /phone/auto_receptionists/{autoReceptionistId}/policies/{policyType}

        Args:
            autoReceptionistId: The unique identifier of the auto receptionist. It can be retrieved from the [List auto receptionists ](https://develope
            policyType: This field corresponds to the policy item you wish to modify.   Allowed values: `voice_mail`
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/auto_receptionists/{autoReceptionistId}/policies/{policyType}".format(autoReceptionistId=autoReceptionistId, policyType=policyType)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_policy" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_policy")

    async def list_billing_account(
        self,
        site_id: str | None = None
    ) -> ZoomResponse:
        """List billing accounts

        HTTP GET /phone/billing_accounts

        Args:
            site_id: The unique identifier of the site. Get it from the [List Phone Sites](https://marketplace.zoom.us/docs/api-reference/pho

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if site_id is not None:
            query_params['site_id'] = site_id

        url = self.base_url + "/phone/billing_accounts"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_billing_account" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_billing_account")

    async def get_a_billing_account(
        self,
        billingAccountId: str
    ) -> ZoomResponse:
        """Get billing account details

        HTTP GET /phone/billing_accounts/{billingAccountId}

        Args:
            billingAccountId: The billing account ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/billing_accounts/{billingAccountId}".format(billingAccountId=billingAccountId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_a_billing_account" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_a_billing_account")

    async def list_blocked_list(
        self,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List blocked lists

        HTTP GET /phone/blocked_list

        Args:
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            page_size: The total number of records returned from a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/blocked_list"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_blocked_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_blocked_list")

    async def add_anumber_to_blocked_list(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a blocked list

        HTTP POST /phone/blocked_list

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/blocked_list"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_anumber_to_blocked_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_anumber_to_blocked_list")

    async def get_a_blocked_list(
        self,
        blockedListId: str
    ) -> ZoomResponse:
        """Get blocked list details

        HTTP GET /phone/blocked_list/{blockedListId}

        Args:
            blockedListId: The unique identifier of the blocked list.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/blocked_list/{blockedListId}".format(blockedListId=blockedListId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_a_blocked_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_a_blocked_list")

    async def delete_a_blocked_list(
        self,
        blockedListId: str
    ) -> ZoomResponse:
        """Delete a blocked list

        HTTP DELETE /phone/blocked_list/{blockedListId}

        Args:
            blockedListId: The unique identifier of the blocked list.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/blocked_list/{blockedListId}".format(blockedListId=blockedListId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_a_blocked_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_a_blocked_list")

    async def update_blocked_list(
        self,
        blockedListId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a blocked list

        HTTP PATCH /phone/blocked_list/{blockedListId}

        Args:
            blockedListId: Unique Identifier of the Blocked List.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/blocked_list/{blockedListId}".format(blockedListId=blockedListId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_blocked_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_blocked_list")

    async def get_call_handling(
        self,
        extensionId: str
    ) -> ZoomResponse:
        """Get call handling settings

        HTTP GET /phone/extension/{extensionId}/call_handling/settings

        Args:
            extensionId: The extension ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/extension/{extensionId}/call_handling/settings".format(extensionId=extensionId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_call_handling" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_call_handling")

    async def add_call_handling(
        self,
        extensionId: str,
        settingType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a call handling setting

        HTTP POST /phone/extension/{extensionId}/call_handling/settings/{settingType}

        Args:
            extensionId: The extension ID.
            settingType: The call handling setting type:  * `business_hours`  * `closed_hours`  * `holiday_hours`
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/extension/{extensionId}/call_handling/settings/{settingType}".format(extensionId=extensionId, settingType=settingType)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_call_handling" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_call_handling")

    async def delete_call_handling(
        self,
        extensionId: str,
        settingType: str,
        call_forwarding_id: str | None = None,
        holiday_id: str | None = None
    ) -> ZoomResponse:
        """Delete a call handling setting

        HTTP DELETE /phone/extension/{extensionId}/call_handling/settings/{settingType}

        Args:
            extensionId: The extension ID.
            settingType: The type of call handling setting:  * `business_hours`  * `closed_hours`  * `holiday_hours`
            call_forwarding_id: The call forwarding's ID. Use this parameter if you pass the `call_forwarding_id` value for the `settingType` parameter.
            holiday_id: The holiday's ID. Use this parameter if you pass the `holiday_id` value for the `settingType` parameter.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if call_forwarding_id is not None:
            query_params['call_forwarding_id'] = call_forwarding_id
        if holiday_id is not None:
            query_params['holiday_id'] = holiday_id

        url = self.base_url + "/phone/extension/{extensionId}/call_handling/settings/{settingType}".format(extensionId=extensionId, settingType=settingType)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_call_handling" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_call_handling")

    async def update_call_handling(
        self,
        extensionId: str,
        settingType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a call handling setting

        HTTP PATCH /phone/extension/{extensionId}/call_handling/settings/{settingType}

        Args:
            extensionId: The extension ID.
            settingType: The call handling setting type:  * `business_hours`  * `closed_hours`  * `holiday_hours`
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/extension/{extensionId}/call_handling/settings/{settingType}".format(extensionId=extensionId, settingType=settingType)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_call_handling" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_call_handling")

    async def get_call_element(
        self,
        callElementId: str
    ) -> ZoomResponse:
        """Get call element

        HTTP GET /phone/call_element/{callElementId}

        Args:
            callElementId: The ID of the call element.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_element/{callElementId}".format(callElementId=callElementId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_call_element" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_call_element")

    async def account_call_history(
        self,
        *,
        page_size: int | None = None,
        from_: str | None = None,
        to: str | None = None,
        next_page_token: str | None = None,
        keyword: str | None = None,
        directions: list[object] | None = None,
        connect_types: list[object] | None = None,
        number_types: list[object] | None = None,
        call_types: list[object] | None = None,
        extension_types: list[object] | None = None,
        call_results: list[object] | None = None,
        group_ids: list[object] | None = None,
        site_ids: list[object] | None = None,
        department: str | None = None,
        cost_center: str | None = None,
        time_type: str | None = None,
        recording_status: str | None = None,
        with_voicemail: bool | None = None
    ) -> ZoomResponse:
        """Get account's call history

        HTTP GET /phone/call_history

        Args:
            page_size: The number of records returned within a single API call.
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format.   The date range defined by the `from`
            to: **Required** only when the `from` parameter is specified.   End time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            keyword: The keyword of the name, extension, number, email address, and call ID. It provides the ability to search by keyword and
            directions: The direction filter of the call logs.
            connect_types: The connect type filter of the call logs.  * `internal`  * `external`
            number_types: The number type filter of the caller or callee.
            call_types: The call type filter of the call logs.  * `general`  * `emergency`
            extension_types: The extension type filter of the call logs.
            call_results: The call result filter of the call logs.
            group_ids: The primary group filter of call logs.
            site_ids: The site filter of call logs.
            department: The department where the call log belongs.
            cost_center: The cost center where the call log belongs.
            time_type: This field enables you to search call logs by start or end time. By default, using start_time
            recording_status: The recording filter indicates whether the whole call has recording or not. Recorded means the call has at least one rec
            with_voicemail: The voicemail filter of the call logs.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if keyword is not None:
            query_params['keyword'] = keyword
        if directions is not None:
            query_params['directions'] = directions
        if connect_types is not None:
            query_params['connect_types'] = connect_types
        if number_types is not None:
            query_params['number_types'] = number_types
        if call_types is not None:
            query_params['call_types'] = call_types
        if extension_types is not None:
            query_params['extension_types'] = extension_types
        if call_results is not None:
            query_params['call_results'] = call_results
        if group_ids is not None:
            query_params['group_ids'] = group_ids
        if site_ids is not None:
            query_params['site_ids'] = site_ids
        if department is not None:
            query_params['department'] = department
        if cost_center is not None:
            query_params['cost_center'] = cost_center
        if time_type is not None:
            query_params['time_type'] = time_type
        if recording_status is not None:
            query_params['recording_status'] = recording_status
        if with_voicemail is not None:
            query_params['with_voicemail'] = str(with_voicemail).lower()

        url = self.base_url + "/phone/call_history"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed account_call_history" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute account_call_history")

    async def get_call_path(
        self,
        callHistoryUuid: str
    ) -> ZoomResponse:
        """Get call history

        HTTP GET /phone/call_history/{callHistoryUuid}

        Args:
            callHistoryUuid: The ID of the call history.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_history/{callHistoryUuid}".format(callHistoryUuid=callHistoryUuid)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_call_path" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_call_path")

    async def add_client_code_to_call_history(
        self,
        callLogId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a client code to a call history

        HTTP PATCH /phone/call_history/{callLogId}/client_code

        Args:
            callLogId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_history/{callLogId}/client_code".format(callLogId=callLogId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_client_code_to_call_history" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_client_code_to_call_history")

    async def get_call_history_detail(
        self,
        callHistoryId: str
    ) -> ZoomResponse:
        """Get call history detail

        HTTP GET /phone/call_history_detail/{callHistoryId}

        Args:
            callHistoryId: The ID of call history.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_history_detail/{callHistoryId}".format(callHistoryId=callHistoryId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_call_history_detail" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_call_history_detail")

    async def account_call_logs(
        self,
        *,
        page_size: int | None = None,
        from_: str | None = None,
        to: str | None = None,
        type_: str | None = None,
        next_page_token: str | None = None,
        path: str | None = None,
        time_type: str | None = None,
        site_id: str | None = None,
        charged_call_logs: bool | None = None
    ) -> ZoomResponse:
        """Get account's call logs

        HTTP GET /phone/call_logs

        Args:
            page_size: The number of records returned within a single API call.
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format. The date range defined by the `from` a
            to: **Required** only when the `from` parameter is specified. End time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss
            type_: The type of the call logs. The value can be either &quot;all&quot; or &quot;missed&quot;.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            path: This field filters the API response by [path](https://support.zoom.us/hc/en-us/articles/360021114452-Viewing-and-identif
            time_type: This field enables you to search call logs by start or end time. You can choose `startTime` or `endTime`.
            site_id: The unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-multiple-sites). Use
            charged_call_logs: Whether to filter API responses to include call logs that only have a non-zero charge.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if type_ is not None:
            query_params['type'] = type_
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if path is not None:
            query_params['path'] = path
        if time_type is not None:
            query_params['time_type'] = time_type
        if site_id is not None:
            query_params['site_id'] = site_id
        if charged_call_logs is not None:
            query_params['charged_call_logs'] = str(charged_call_logs).lower()

        url = self.base_url + "/phone/call_logs"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed account_call_logs" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute account_call_logs")

    async def get_call_log_details(
        self,
        callLogId: str
    ) -> ZoomResponse:
        """Get call log details

        HTTP GET /phone/call_logs/{callLogId}

        Args:
            callLogId: The unique identifier of the call log. Both `callLogId` and `callId` can be used as path parameters. The value for this

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_logs/{callLogId}".format(callLogId=callLogId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_call_log_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_call_log_details")

    async def add_client_code_to_call_log(
        self,
        callLogId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a client code to a call log

        HTTP PUT /phone/call_logs/{callLogId}/client_code

        Args:
            callLogId: The unique identifier of the call log.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_logs/{callLogId}/client_code".format(callLogId=callLogId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_client_code_to_call_log" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_client_code_to_call_log")

    async def get_user_ai_call_summary(
        self,
        userId: str,
        aiCallSummaryId: str
    ) -> ZoomResponse:
        """Get User AI Call Summary Detail

        HTTP GET /phone/user/{userId}/ai_call_summary/{aiCallSummaryId}

        Args:
            userId: The owner's user ID.
            aiCallSummaryId: The ID of the AI call summary.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/user/{userId}/ai_call_summary/{aiCallSummaryId}".format(userId=userId, aiCallSummaryId=aiCallSummaryId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_user_ai_call_summary" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_user_ai_call_summary")

    async def phone_user_call_history(
        self,
        userId: str,
        *,
        page_size: int | None = None,
        from_: str | None = None,
        to: str | None = None,
        next_page_token: str | None = None,
        keyword: str | None = None,
        directions: list[object] | None = None,
        connect_types: list[object] | None = None,
        number_types: list[object] | None = None,
        call_types: list[object] | None = None,
        extension_types: list[object] | None = None,
        call_results: list[object] | None = None,
        group_ids: list[object] | None = None,
        site_ids: list[object] | None = None,
        department: str | None = None,
        cost_center: str | None = None,
        time_type: str | None = None,
        recording_status: str | None = None,
        with_voicemail: bool | None = None
    ) -> ZoomResponse:
        """Get user's call history

        HTTP GET /phone/users/{userId}/call_history

        Args:
            userId: The user ID or email address of the user. For user-level apps, pass `me` as the value for userId.
            page_size: The number of records returned within a single API call.
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format.   The date range defined by the `from`
            to: **Required** only when the `from` parameter is specified.   End time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            keyword: The keyword of the name, extension, number, email address, and call ID. It provides the ability to search by keyword and
            directions: The direction filter of the call logs.
            connect_types: The connect type filter of the call logs.  * `internal`  * `external`
            number_types: The number type filter of the caller or callee.
            call_types: The call type filter of the call logs.  * `general`  * `emergency`
            extension_types: The extension type filter of the call logs.
            call_results: The call result filter of the call logs.
            group_ids: The primary group filter of call logs.
            site_ids: The site filter of call logs.
            department: The department of which the call log belongs.
            cost_center: The cost center of which the call log belongs.
            time_type: This field enables you to search call logs by start or end time. By default, using start_time
            recording_status: The recording filter indicates whether the whole call has recording or not. recorded means the call has at least one rec
            with_voicemail: The voicemail filter of the call logs.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if keyword is not None:
            query_params['keyword'] = keyword
        if directions is not None:
            query_params['directions'] = directions
        if connect_types is not None:
            query_params['connect_types'] = connect_types
        if number_types is not None:
            query_params['number_types'] = number_types
        if call_types is not None:
            query_params['call_types'] = call_types
        if extension_types is not None:
            query_params['extension_types'] = extension_types
        if call_results is not None:
            query_params['call_results'] = call_results
        if group_ids is not None:
            query_params['group_ids'] = group_ids
        if site_ids is not None:
            query_params['site_ids'] = site_ids
        if department is not None:
            query_params['department'] = department
        if cost_center is not None:
            query_params['cost_center'] = cost_center
        if time_type is not None:
            query_params['time_type'] = time_type
        if recording_status is not None:
            query_params['recording_status'] = recording_status
        if with_voicemail is not None:
            query_params['with_voicemail'] = str(with_voicemail).lower()

        url = self.base_url + "/phone/users/{userId}/call_history".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed phone_user_call_history" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute phone_user_call_history")

    async def sync_user_call_history(
        self,
        userId: str,
        sync_type: str | None = None,
        count: int | None = None,
        sync_token: str | None = None
    ) -> ZoomResponse:
        """Sync user's call history

        HTTP GET /phone/users/{userId}/call_history/sync

        Args:
            userId: Path parameter
            sync_type: The options for synchronizing call log:   FSync - Full sync   ISync - Increase sync   BSync - Backward sync
            count: The number of records returned within a single API call.
            sync_token: The time range for returned records. It's used for locating where the next retrieval will begin.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if sync_type is not None:
            query_params['sync_type'] = sync_type
        if count is not None:
            query_params['count'] = str(count)
        if sync_token is not None:
            query_params['sync_token'] = sync_token

        url = self.base_url + "/phone/users/{userId}/call_history/sync".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed sync_user_call_history" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute sync_user_call_history")

    async def delete_user_call_history(
        self,
        userId: str,
        callLogId: str
    ) -> ZoomResponse:
        """Delete a user's call history

        HTTP DELETE /phone/users/{userId}/call_history/{callLogId}

        Args:
            userId: The user ID or email address of the user.
            callLogId: The unique identifier of the call log. The value for this field can be retrieved from [account's call logs](https://mark

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/call_history/{callLogId}".format(userId=userId, callLogId=callLogId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_user_call_history" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_user_call_history")

    async def phone_user_call_logs(
        self,
        userId: str,
        page_size: int | None = None,
        from_: str | None = None,
        to: str | None = None,
        type_: str | None = None,
        next_page_token: str | None = None,
        phone_number: str | None = None,
        time_type: str | None = None
    ) -> ZoomResponse:
        """Get user's call logs

        HTTP GET /phone/users/{userId}/call_logs

        Args:
            userId: The user ID or email address of the user. For user-level apps, pass `me` as the value for userId.
            page_size: The number of records returned within a single API call.
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format. The date range defined by the `from` a
            to: **Required** only when the `from` parameter is specified. End time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss
            type_: Query parameter
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            phone_number: This field filters API responses to include call logs of only the phone number defined in this field.
            time_type: This field enables you to sort call logs by start or end time. Choose the sort time value. Values include `startTime` or

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if type_ is not None:
            query_params['type'] = type_
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if phone_number is not None:
            query_params['phone_number'] = phone_number
        if time_type is not None:
            query_params['time_type'] = time_type

        url = self.base_url + "/phone/users/{userId}/call_logs".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed phone_user_call_logs" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute phone_user_call_logs")

    async def sync_user_call_logs(
        self,
        userId: str,
        sync_type: str | None = None,
        count: int | None = None,
        sync_token: str | None = None
    ) -> ZoomResponse:
        """Sync user's call logs

        HTTP GET /phone/users/{userId}/call_logs/sync

        Args:
            userId: The user ID.
            sync_type: The options for synchronizing call log:     FSync - Full sync     ISync - Increase sync     BSync - Backward sync
            count: The number of records returned within a single API call.
            sync_token: The time range for returned records. It's used for locating where the next retrieval will begin.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if sync_type is not None:
            query_params['sync_type'] = sync_type
        if count is not None:
            query_params['count'] = str(count)
        if sync_token is not None:
            query_params['sync_token'] = sync_token

        url = self.base_url + "/phone/users/{userId}/call_logs/sync".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed sync_user_call_logs" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute sync_user_call_logs")

    async def delete_call_log(
        self,
        userId: str,
        callLogId: str
    ) -> ZoomResponse:
        """Delete a user's call log

        HTTP DELETE /phone/users/{userId}/call_logs/{callLogId}

        Args:
            userId: The user ID or email address of the user.
            callLogId: The unique identifier of the call log. The value for this field can be retrieved from [account's call logs](https://mark

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/call_logs/{callLogId}".format(userId=userId, callLogId=callLogId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_call_log" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_call_log")

    async def callqueueanalytics(
        self,
        page_size: int | None = None,
        from_: str | None = None,
        to: str | None = None,
        next_page_token: str | None = None,
        site_id: str | None = None,
        call_queue_ext_ids: list[object] | None = None,
        department: str | None = None,
        cost_center: str | None = None
    ) -> ZoomResponse:
        """List call queue analytics

        HTTP GET /phone/call_queue_analytics

        Args:
            page_size: The number of records returned within a single API call.
            from_: The call start time in GMT **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format. The earliest data available for query
            to: The call end time in GMT **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format. Queries must be within a one-year interv
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            site_id: The unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-Multiple-Sites) wher
            call_queue_ext_ids: The call queue extension ID list.
            department: The department of which the call queue belongs.
            cost_center: The cost center where the call queue belongs.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if site_id is not None:
            query_params['site_id'] = site_id
        if call_queue_ext_ids is not None:
            query_params['call_queue_ext_ids'] = call_queue_ext_ids
        if department is not None:
            query_params['department'] = department
        if cost_center is not None:
            query_params['cost_center'] = cost_center

        url = self.base_url + "/phone/call_queue_analytics"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed callqueueanalytics" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute callqueueanalytics")

    async def list_call_queues(
        self,
        next_page_token: str | None = None,
        page_size: int | None = None,
        site_id: str | None = None,
        cost_center: str | None = None,
        department: str | None = None
    ) -> ZoomResponse:
        """List call queues

        HTTP GET /phone/call_queues

        Args:
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            page_size: The number of records returned from a single API call.
            site_id: Unique identifier of the site. Get it from the [List Phone Sites](https://marketplace.zoom.us/docs/api-reference/phone/m
            cost_center: The call queue's cost center.
            department: The call queue's department.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if site_id is not None:
            query_params['site_id'] = site_id
        if cost_center is not None:
            query_params['cost_center'] = cost_center
        if department is not None:
            query_params['department'] = department

        url = self.base_url + "/phone/call_queues"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_call_queues" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_call_queues")

    async def create_call_queue(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a call queue

        HTTP POST /phone/call_queues

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_queues"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_call_queue" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_call_queue")

    async def get_a_call_queue(
        self,
        callQueueId: str
    ) -> ZoomResponse:
        """Get call queue details

        HTTP GET /phone/call_queues/{callQueueId}

        Args:
            callQueueId: The unique identifier of the call queue. You can retrieve it from the [List Call Queues API](https://marketplace.zoom.us

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_queues/{callQueueId}".format(callQueueId=callQueueId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_a_call_queue" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_a_call_queue")

    async def delete_a_call_queue(
        self,
        callQueueId: str
    ) -> ZoomResponse:
        """Delete a call queue

        HTTP DELETE /phone/call_queues/{callQueueId}

        Args:
            callQueueId: Unique identifier of the call queue.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_queues/{callQueueId}".format(callQueueId=callQueueId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_a_call_queue" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_a_call_queue")

    async def update_call_queue(
        self,
        callQueueId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update call queue details

        HTTP PATCH /phone/call_queues/{callQueueId}

        Args:
            callQueueId: The call queue ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_queues/{callQueueId}".format(callQueueId=callQueueId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_call_queue" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_call_queue")

    async def list_call_queue_members(
        self,
        callQueueId: str
    ) -> ZoomResponse:
        """List call queue members

        HTTP GET /phone/call_queues/{callQueueId}/members

        Args:
            callQueueId: The call queue ID that is retrievable from the [List Call Queues](https://marketplace.zoom.us/docs/api-reference/phone/m

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_queues/{callQueueId}/members".format(callQueueId=callQueueId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_call_queue_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_call_queue_members")

    async def add_members_to_call_queue(
        self,
        callQueueId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add members to a call queue

        HTTP POST /phone/call_queues/{callQueueId}/members

        Args:
            callQueueId: The call queue ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_queues/{callQueueId}/members".format(callQueueId=callQueueId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_members_to_call_queue" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_members_to_call_queue")

    async def unassign_all_members(
        self,
        callQueueId: str
    ) -> ZoomResponse:
        """Unassign all members

        HTTP DELETE /phone/call_queues/{callQueueId}/members

        Args:
            callQueueId: Path parameter

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_queues/{callQueueId}/members".format(callQueueId=callQueueId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed unassign_all_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute unassign_all_members")

    async def unassign_member_from_call_queue(
        self,
        callQueueId: str,
        memberId: str
    ) -> ZoomResponse:
        """Unassign a member

        HTTP DELETE /phone/call_queues/{callQueueId}/members/{memberId}

        Args:
            callQueueId: Unique identifier of the Call Queue from which the member needs to be unassigned.
            memberId: Unique identifier of the member who needs to be unassigned.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_queues/{callQueueId}/members/{memberId}".format(callQueueId=callQueueId, memberId=memberId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed unassign_member_from_call_queue" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute unassign_member_from_call_queue")

    async def assign_phone_to_call_queue(
        self,
        callQueueId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign numbers to a call queue

        HTTP POST /phone/call_queues/{callQueueId}/phone_numbers

        Args:
            callQueueId: The unique identifier of the call queue.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_queues/{callQueueId}/phone_numbers".format(callQueueId=callQueueId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assign_phone_to_call_queue" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assign_phone_to_call_queue")

    async def unassign_a_phone_num_call_queue(
        self,
        callQueueId: str
    ) -> ZoomResponse:
        """Unassign all phone numbers

        HTTP DELETE /phone/call_queues/{callQueueId}/phone_numbers

        Args:
            callQueueId: The unique identifier of the call queue.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_queues/{callQueueId}/phone_numbers".format(callQueueId=callQueueId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed unassign_a_phone_num_call_queue" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute unassign_a_phone_num_call_queue")

    async def un_assign_phone_num_call_queue(
        self,
        callQueueId: str,
        phoneNumberId: str
    ) -> ZoomResponse:
        """Unassign a phone number

        HTTP DELETE /phone/call_queues/{callQueueId}/phone_numbers/{phoneNumberId}

        Args:
            callQueueId: The unique identifier of the call queue.
            phoneNumberId: The phone number ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_queues/{callQueueId}/phone_numbers/{phoneNumberId}".format(callQueueId=callQueueId, phoneNumberId=phoneNumberId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed un_assign_phone_num_call_queue" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute un_assign_phone_num_call_queue")

    async def add_cq_policy_sub_setting(
        self,
        callQueueId: str,
        policyType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a policy subsetting to a call queue

        HTTP POST /phone/call_queues/{callQueueId}/policies/{policyType}

        Args:
            callQueueId: The call queue ID that is retrievable the [List Call Queues](https://developers.zoom.us/docs/api/rest/reference/phone/me
            policyType: This field corresponds to the policy sub-setting item you wish to add.   Allowed values: `voice_mail`.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_queues/{callQueueId}/policies/{policyType}".format(callQueueId=callQueueId, policyType=policyType)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_cq_policy_sub_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_cq_policy_sub_setting")

    async def remove_cq_policy_sub_setting(
        self,
        callQueueId: str,
        policyType: str,
        shared_ids: list[object] | None = None
    ) -> ZoomResponse:
        """Delete a CQ policy setting

        HTTP DELETE /phone/call_queues/{callQueueId}/policies/{policyType}

        Args:
            callQueueId: The call queue ID, retrievable from the [List Call Queues](https://marketplace.zoom.us/docs/api-reference/phone/methods#
            policyType: Corresponds to tbe policy sub-setting item you wish to remove. Allowed values: `voice_mail`
            shared_ids: Comma separated list of shared IDs to remove. The number is limited to the minimum value of 10 or the number of allowed

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if shared_ids is not None:
            query_params['shared_ids'] = shared_ids

        url = self.base_url + "/phone/call_queues/{callQueueId}/policies/{policyType}".format(callQueueId=callQueueId, policyType=policyType)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed remove_cq_policy_sub_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute remove_cq_policy_sub_setting")

    async def update_cq_policy_sub_setting(
        self,
        callQueueId: str,
        policyType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a call queue's policy subsetting

        HTTP PATCH /phone/call_queues/{callQueueId}/policies/{policyType}

        Args:
            callQueueId: The call queue ID that is retrievable from the [List Call Queues](https://developers.zoom.us/docs/api/rest/reference/pho
            policyType: The field that corresponds to the policy sub-setting item you wish to update. Allowed values: `voice_mail`.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_queues/{callQueueId}/policies/{policyType}".format(callQueueId=callQueueId, policyType=policyType)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_cq_policy_sub_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_cq_policy_sub_setting")

    async def get_call_queue_recordings(
        self,
        callQueueId: str,
        page_size: int | None = None,
        next_page_token: str | None = None,
        from_: str | None = None,
        to: str | None = None
    ) -> ZoomResponse:
        """Get call queue recordings

        HTTP GET /phone/call_queues/{callQueueId}/recordings

        Args:
            callQueueId: Unique identifier of the Call Queue.
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format. The date range defined by the `from` a
            to: **Required** only when the `from` parameter is specified. End time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to

        url = self.base_url + "/phone/call_queues/{callQueueId}/recordings".format(callQueueId=callQueueId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_call_queue_recordings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_call_queue_recordings")

    async def list_cr_phone_numbers(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        assigned_status: str | None = None,
        sub_account_id: str | None = None,
        keyword: str | None = None
    ) -> ZoomResponse:
        """List phone numbers

        HTTP GET /phone/carrier_reseller/numbers

        Args:
            page_size: The size of the page.
            next_page_token: The current page number of returned records.
            assigned_status: Number assignment status.
            sub_account_id: Partner account ID from sub-account.
            keyword: Partial string of the phone number.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if assigned_status is not None:
            query_params['assigned_status'] = assigned_status
        if sub_account_id is not None:
            query_params['sub_account_id'] = sub_account_id
        if keyword is not None:
            query_params['keyword'] = keyword

        url = self.base_url + "/phone/carrier_reseller/numbers"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_cr_phone_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_cr_phone_numbers")

    async def create_cr_phone_numbers(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create phone numbers

        HTTP POST /phone/carrier_reseller/numbers

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/carrier_reseller/numbers"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_cr_phone_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_cr_phone_numbers")

    async def active_cr_phone_numbers(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Activate phone numbers

        HTTP PATCH /phone/carrier_reseller/numbers

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/carrier_reseller/numbers"

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed active_cr_phone_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute active_cr_phone_numbers")

    async def delete_cr_phone_number(
        self,
        number: str
    ) -> ZoomResponse:
        """Delete a phone number

        HTTP DELETE /phone/carrier_reseller/numbers/{number}

        Args:
            number: Phone number in E164 format.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/carrier_reseller/numbers/{number}".format(number=number)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_cr_phone_number" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_cr_phone_number")

    async def list_common_areas(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List common areas

        HTTP GET /phone/common_areas

        Args:
            page_size: The total number of records returned from a single API call.
            next_page_token: The next page token paginates through large result sets. A next page token returns whenever the set of available results

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/common_areas"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_common_areas" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_common_areas")

    async def add_common_area(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a common area

        HTTP POST /phone/common_areas

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_common_area" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_common_area")

    async def generateactivationcodesforcommonareas(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Generate activation codes for common areas

        HTTP POST /phone/common_areas/activation_code

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/activation_code"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed generateactivationcodesforcommonareas" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute generateactivationcodesforcommonareas")

    async def list_activation_codes(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List activation codes

        HTTP GET /phone/common_areas/activation_codes

        Args:
            page_size: The total number of records returned from a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/common_areas/activation_codes"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_activation_codes" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_activation_codes")

    async def apply_templateto_common_areas(
        self,
        templateId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Apply template to common areas

        HTTP POST /phone/common_areas/template_id/{templateId}

        Args:
            templateId: The template ID is the unique identifier of the [Setting Template](https://support.zoom.com/hc/en/article?id=zm_kb&syspa
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/template_id/{templateId}".format(templateId=templateId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed apply_templateto_common_areas" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute apply_templateto_common_areas")

    async def get_a_common_area(
        self,
        commonAreaId: str
    ) -> ZoomResponse:
        """Get common area details

        HTTP GET /phone/common_areas/{commonAreaId}

        Args:
            commonAreaId: The common area ID or common area extension ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/{commonAreaId}".format(commonAreaId=commonAreaId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_a_common_area" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_a_common_area")

    async def delete_common_area(
        self,
        commonAreaId: str
    ) -> ZoomResponse:
        """Delete a common area

        HTTP DELETE /phone/common_areas/{commonAreaId}

        Args:
            commonAreaId: The common area ID or common area extension ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/{commonAreaId}".format(commonAreaId=commonAreaId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_common_area" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_common_area")

    async def update_common_area(
        self,
        commonAreaId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update common area

        HTTP PATCH /phone/common_areas/{commonAreaId}

        Args:
            commonAreaId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/{commonAreaId}".format(commonAreaId=commonAreaId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_common_area" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_common_area")

    async def assign_calling_plans_to_common_area(
        self,
        commonAreaId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign calling plans to a common area

        HTTP POST /phone/common_areas/{commonAreaId}/calling_plans

        Args:
            commonAreaId: The common area ID or common area extension ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/{commonAreaId}/calling_plans".format(commonAreaId=commonAreaId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assign_calling_plans_to_common_area" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assign_calling_plans_to_common_area")

    async def unassign_calling_plans_from_common_area(
        self,
        commonAreaId: str,
        type_: str,
        billing_account_id: str | None = None
    ) -> ZoomResponse:
        """Unassign a calling plan from the common area

        HTTP DELETE /phone/common_areas/{commonAreaId}/calling_plans/{type}

        Args:
            commonAreaId: The Common area ID or common area extension ID.
            type_: The Zoom Phone [calling plan](https://marketplace.zoom.us/docs/api-reference/other-references/plans#zoom-phone-calling-p
            billing_account_id: The billing account ID. If the common area is in India, the parameter is required.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if billing_account_id is not None:
            query_params['billing_account_id'] = billing_account_id

        url = self.base_url + "/phone/common_areas/{commonAreaId}/calling_plans/{type_}".format(commonAreaId=commonAreaId, type_=type_)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed unassign_calling_plans_from_common_area" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute unassign_calling_plans_from_common_area")

    async def assign_phone_numbers_to_common_area(
        self,
        commonAreaId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign phone numbers to a common area

        HTTP POST /phone/common_areas/{commonAreaId}/phone_numbers

        Args:
            commonAreaId: The common area ID or common area extension ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/{commonAreaId}/phone_numbers".format(commonAreaId=commonAreaId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assign_phone_numbers_to_common_area" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assign_phone_numbers_to_common_area")

    async def unassign_phone_numbers_from_common_area(
        self,
        commonAreaId: str,
        phoneNumberId: str
    ) -> ZoomResponse:
        """Unassign phone numbers from common area

        HTTP DELETE /phone/common_areas/{commonAreaId}/phone_numbers/{phoneNumberId}

        Args:
            commonAreaId: The common area ID or common area extension ID.
            phoneNumberId: The phone number or the phone number ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/{commonAreaId}/phone_numbers/{phoneNumberId}".format(commonAreaId=commonAreaId, phoneNumberId=phoneNumberId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed unassign_phone_numbers_from_common_area" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute unassign_phone_numbers_from_common_area")

    async def update_common_area_pin_code(
        self,
        commonAreaId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update common area pin code

        HTTP PATCH /phone/common_areas/{commonAreaId}/pin_code

        Args:
            commonAreaId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/{commonAreaId}/pin_code".format(commonAreaId=commonAreaId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_common_area_pin_code" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_common_area_pin_code")

    async def get_common_area_settings(
        self,
        commonAreaId: str
    ) -> ZoomResponse:
        """Get common area settings

        HTTP GET /phone/common_areas/{commonAreaId}/settings

        Args:
            commonAreaId: Path parameter

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/{commonAreaId}/settings".format(commonAreaId=commonAreaId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_common_area_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_common_area_settings")

    async def add_common_area_setting(
        self,
        commonAreaId: str,
        settingType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add common area setting

        HTTP POST /phone/common_areas/{commonAreaId}/settings/{settingType}

        Args:
            commonAreaId: The common area ID or common area extension ID.
            settingType: This field corresponds to the setting item you wish to modify. Allowed values: `desk_phone`
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/{commonAreaId}/settings/{settingType}".format(commonAreaId=commonAreaId, settingType=settingType)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_common_area_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_common_area_setting")

    async def delete_common_area_setting(
        self,
        commonAreaId: str,
        settingType: str,
        device_id: str | None = None
    ) -> ZoomResponse:
        """Delete common area setting

        HTTP DELETE /phone/common_areas/{commonAreaId}/settings/{settingType}

        Args:
            commonAreaId: The common area ID or common area extension ID.
            settingType: This setting corresponds to the setting item you want to modify. Allowed values: `desk_phone`
            device_id: The desk phone ID.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if device_id is not None:
            query_params['device_id'] = device_id

        url = self.base_url + "/phone/common_areas/{commonAreaId}/settings/{settingType}".format(commonAreaId=commonAreaId, settingType=settingType)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_common_area_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_common_area_setting")

    async def update_common_area_setting(
        self,
        commonAreaId: str,
        settingType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update common area setting

        HTTP PATCH /phone/common_areas/{commonAreaId}/settings/{settingType}

        Args:
            commonAreaId: Path parameter
            settingType: This field corresponds to the setting item you wish to modify. Allowed values: `desk_phone`
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/{commonAreaId}/settings/{settingType}".format(commonAreaId=commonAreaId, settingType=settingType)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_common_area_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_common_area_setting")

    async def list_call_logs_metrics(
        self,
        from_: str | None = None,
        to: str | None = None,
        site_id: str | None = None,
        quality_type: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List call logs

        HTTP GET /phone/metrics/call_logs

        Args:
            from_: The start date in **yyyy-mm-dd** format. The date range defined by the `from` and `to` parameters should be a month as t
            to: This setting is **required** only when the `from` parameter is specified. The end date is in **yyyy-mm-dd** format, whic
            site_id: The unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-multiple-sites). Use
            quality_type: This setting filters call logs by voice quality. Zoom uses MOS of 3.5 as a general baseline to categorize calls by call
            page_size: The number of records returned within a single call.
            next_page_token: The next page token paginates through a large set of results. A next page token will be returned whenever the set of ava

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if site_id is not None:
            query_params['site_id'] = site_id
        if quality_type is not None:
            query_params['quality_type'] = quality_type
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/metrics/call_logs"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_call_logs_metrics" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_call_logs_metrics")

    async def get_call_qo_s(
        self,
        callId: str
    ) -> ZoomResponse:
        """Get call QoS

        HTTP GET /phone/metrics/call_logs/{callId}/qos

        Args:
            callId: The unique identifier of the call.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/metrics/call_logs/{callId}/qos".format(callId=callId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_call_qo_s" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_call_qo_s")

    async def get_call_log_metrics_details(
        self,
        call_id: str
    ) -> ZoomResponse:
        """Get call details from call log

        HTTP GET /phone/metrics/call_logs/{call_id}

        Args:
            call_id: The unique identifier of the phone call.  The value of this field can be retrieved from [List Call Logs]() API.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/metrics/call_logs/{call_id}".format(call_id=call_id)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_call_log_metrics_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_call_log_metrics_details")

    async def list_user_default_emergency_address(
        self,
        status: str | None = None,
        site_id: str | None = None,
        keyword: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List default emergency address users

        HTTP GET /phone/metrics/emergency_services/default_emergency_address/users

        Args:
            status: The status of **Default Emergency Address**.
            site_id: The site's ID.
            keyword: The name, email, or extension number of the user.
            page_size: The number of records returned within a single call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if status is not None:
            query_params['status'] = status
        if site_id is not None:
            query_params['site_id'] = site_id
        if keyword is not None:
            query_params['keyword'] = keyword
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/metrics/emergency_services/default_emergency_address/users"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_user_default_emergency_address" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_user_default_emergency_address")

    async def list_user_detectable_personal_location(
        self,
        status: str | None = None,
        site_id: str | None = None,
        keyword: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List detectable personal location users

        HTTP GET /phone/metrics/emergency_services/detectable_personal_location/users

        Args:
            status: The status of **Detectable Personal Location**.
            site_id: The site's ID.
            keyword: The name, email, or extension number of the user.
            page_size: The number of records returned within a single call.
            next_page_token: The next page token paginates through a large set of results. It returns whenever the set of available results exceeds t

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if status is not None:
            query_params['status'] = status
        if site_id is not None:
            query_params['site_id'] = site_id
        if keyword is not None:
            query_params['keyword'] = keyword
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/metrics/emergency_services/detectable_personal_location/users"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_user_detectable_personal_location" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_user_detectable_personal_location")

    async def list_user_location_sharing_permission(
        self,
        site_id: str | None = None,
        keyword: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List users permission for location sharing

        HTTP GET /phone/metrics/emergency_services/location_sharing_permission/users

        Args:
            site_id: The site's ID.
            keyword: The name, email, or extension number of the user.
            page_size: The number of records returned within a single call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if site_id is not None:
            query_params['site_id'] = site_id
        if keyword is not None:
            query_params['keyword'] = keyword
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/metrics/emergency_services/location_sharing_permission/users"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_user_location_sharing_permission" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_user_location_sharing_permission")

    async def list_user_nomadic_emergency_services(
        self,
        status: str | None = None,
        site_id: str | None = None,
        keyword: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List nomadic emergency services users

        HTTP GET /phone/metrics/emergency_services/nomadic_emergency_services/users

        Args:
            status: The status of **Nomadic Emergency Services is disabled**.
            site_id: The site's ID.
            keyword: The name, email, or extension number of the user.
            page_size: The number of records returned within a single call.
            next_page_token: The next page token paginates through a large set of results. It returns whenever the set of available results exceeds t

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if status is not None:
            query_params['status'] = status
        if site_id is not None:
            query_params['site_id'] = site_id
        if keyword is not None:
            query_params['keyword'] = keyword
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/metrics/emergency_services/nomadic_emergency_services/users"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_user_nomadic_emergency_services" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_user_nomadic_emergency_services")

    async def list_phone_realtimelocation(
        self,
        location_type: str | None = None,
        site_id: str | None = None,
        keyword: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List real time location for IP phones

        HTTP GET /phone/metrics/emergency_services/realtime_location/devices

        Args:
            location_type: The location's type.
            site_id: The site's ID.
            keyword: The device name or device MAC address.
            page_size: The number of records returned within a single call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if location_type is not None:
            query_params['location_type'] = location_type
        if site_id is not None:
            query_params['site_id'] = site_id
        if keyword is not None:
            query_params['keyword'] = keyword
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/metrics/emergency_services/realtime_location/devices"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_phone_realtimelocation" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_phone_realtimelocation")

    async def list_user_realtime_location(
        self,
        location_type: str | None = None,
        site_id: str | None = None,
        keyword: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List real time location for users

        HTTP GET /phone/metrics/emergency_services/realtime_location/users

        Args:
            location_type: The location's type.
            site_id: The site's ID.
            keyword: The name, email or extension number of the user.
            page_size: The number of records returned within a single call.
            next_page_token: The next page token paginates through a large set of results. It returns whenever the set of available results exceeds t

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if location_type is not None:
            query_params['location_type'] = location_type
        if site_id is not None:
            query_params['site_id'] = site_id
        if keyword is not None:
            query_params['keyword'] = keyword
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/metrics/emergency_services/realtime_location/users"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_user_realtime_location" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_user_realtime_location")

    async def list_tracked_locations(
        self,
        type_: int | None = None,
        site_id: str | None = None,
        location_type: str | None = None,
        keyword: str | None = None
    ) -> ZoomResponse:
        """List tracked locations

        HTTP GET /phone/metrics/location_tracking

        Args:
            type_: The type of response data. Supports  only six responses at this time. `1`: Nomadic Emergency Services. `2`: Users Permis
            site_id: The site's ID.
            location_type: The location's type. 'Company' is the default value.
            keyword: The device name or device MAC address.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = str(type_)
        if site_id is not None:
            query_params['site_id'] = site_id
        if location_type is not None:
            query_params['location_type'] = location_type
        if keyword is not None:
            query_params['keyword'] = keyword

        url = self.base_url + "/phone/metrics/location_tracking"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_tracked_locations" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_tracked_locations")

    async def list_past_call_metrics(
        self,
        from_: str | None = None,
        to: str | None = None,
        phone_number: str | None = None,
        extension_number: str | None = None,
        quality_type: str | None = None,
        department: str | None = None,
        cost_center: str | None = None,
        directions: list[object] | None = None,
        durations: list[object] | None = None,
        site_id: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List past call metrics

        HTTP GET /phone/metrics/past_calls

        Args:
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format. The date range defined by the `from` a
            to: **Required** only when the `from` parameter is specified. End time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss
            phone_number: This setting filters call logs of a specified phone number.
            extension_number: This setting filters call logs of a specified extension number
            quality_type: This setting filters call logs by voice quality. Zoom uses MOS of 3.5 as a general baseline to categorize calls by call
            department: The department the extension belongs to.
            cost_center: The cost center the extension belongs to.
            directions: The directions of the call.
            durations: The duration of the call.      * `0`: The call that lasts 1 to 5 minutes.      * `1`: The call that lasts 5 to 10 minute
            site_id: The unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-multiple-sites). Use
            page_size: The number of records returned within a single call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if phone_number is not None:
            query_params['phone_number'] = phone_number
        if extension_number is not None:
            query_params['extension_number'] = extension_number
        if quality_type is not None:
            query_params['quality_type'] = quality_type
        if department is not None:
            query_params['department'] = department
        if cost_center is not None:
            query_params['cost_center'] = cost_center
        if directions is not None:
            query_params['directions'] = directions
        if durations is not None:
            query_params['durations'] = durations
        if site_id is not None:
            query_params['site_id'] = site_id
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/metrics/past_calls"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_past_call_metrics" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_past_call_metrics")

    async def list_device_line_key_setting(
        self,
        deviceId: str
    ) -> ZoomResponse:
        """Get device line keys information

        HTTP GET /phone/devices/{deviceId}/line_keys

        Args:
            deviceId: The device ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/devices/{deviceId}/line_keys".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_device_line_key_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_device_line_key_setting")

    async def batch_update_device_line_key_setting(
        self,
        deviceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Batch update device line key position

        HTTP PATCH /phone/devices/{deviceId}/line_keys

        Args:
            deviceId: The device ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/devices/{deviceId}/line_keys".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed batch_update_device_line_key_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute batch_update_device_line_key_setting")

    async def list_users_from_directory(
        self,
        *,
        page_size: int | None = None,
        next_page_token: str | None = None,
        in_directory: bool | None = None,
        site_id: str | None = None
    ) -> ZoomResponse:
        """List users in directory

        HTTP GET /phone/dial_by_name_directory/extensions

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            in_directory: Whether the user belongs to the directory.
            site_id: Unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-multiple-sites).

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if in_directory is not None:
            query_params['in_directory'] = str(in_directory).lower()
        if site_id is not None:
            query_params['site_id'] = site_id

        url = self.base_url + "/phone/dial_by_name_directory/extensions"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_users_from_directory" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_users_from_directory")

    async def add_users_to_directory(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add users to a directory

        HTTP POST /phone/dial_by_name_directory/extensions

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/dial_by_name_directory/extensions"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_users_to_directory" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_users_to_directory")

    async def delete_users_from_directory(
        self,
        site_id: str | None = None,
        extension_ids: list[object] | None = None
    ) -> ZoomResponse:
        """Delete users from a directory

        HTTP DELETE /phone/dial_by_name_directory/extensions

        Args:
            site_id: Unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-multiple-sites)
            extension_ids: Extension Ids. If the value is not specified, delete the value of `site_id` from  `included sites` and delete all users

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if site_id is not None:
            query_params['site_id'] = site_id
        if extension_ids is not None:
            query_params['extension_ids'] = extension_ids

        url = self.base_url + "/phone/dial_by_name_directory/extensions"

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_users_from_directory" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_users_from_directory")

    async def list_users_from_directory_by_site(
        self,
        siteId: str,
        *,
        page_size: int | None = None,
        next_page_token: str | None = None,
        in_directory: bool | None = None,
        site_id: str | None = None
    ) -> ZoomResponse:
        """List users in a directory by site

        HTTP GET /phone/sites/{siteId}/dial_by_name_directory/extensions

        Args:
            siteId: Unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-multiple-sites).
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            in_directory: Whether the user belongs to the directory.
            site_id: Unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-multiple-sites) to which

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if in_directory is not None:
            query_params['in_directory'] = str(in_directory).lower()
        if site_id is not None:
            query_params['site_id'] = site_id

        url = self.base_url + "/phone/sites/{siteId}/dial_by_name_directory/extensions".format(siteId=siteId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_users_from_directory_by_site" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_users_from_directory_by_site")

    async def add_users_to_directory_by_site(
        self,
        siteId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add users to a directory of a site

        HTTP POST /phone/sites/{siteId}/dial_by_name_directory/extensions

        Args:
            siteId: Unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-multiple-sites).
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sites/{siteId}/dial_by_name_directory/extensions".format(siteId=siteId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_users_to_directory_by_site" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_users_to_directory_by_site")

    async def delete_users_from_directory_by_site(
        self,
        siteId: str,
        site_id: str | None = None,
        extension_ids: list[object] | None = None
    ) -> ZoomResponse:
        """Delete users from a directory of a site

        HTTP DELETE /phone/sites/{siteId}/dial_by_name_directory/extensions

        Args:
            siteId: Unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-multiple-sites).
            site_id: Unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-multiple-sites) to which
            extension_ids: Extension Ids. If the value is not specified, delete the value of `site_id` from  `included sites` and delete all users

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if site_id is not None:
            query_params['site_id'] = site_id
        if extension_ids is not None:
            query_params['extension_ids'] = extension_ids

        url = self.base_url + "/phone/sites/{siteId}/dial_by_name_directory/extensions".format(siteId=siteId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_users_from_directory_by_site" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_users_from_directory_by_site")

    async def list_emergency_addresses(
        self,
        site_id: str | None = None,
        user_id: str | None = None,
        level: int | None = None,
        status: int | None = None,
        address_keyword: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List emergency addresses

        HTTP GET /phone/emergency_addresses

        Args:
            site_id: The emergency address site ID.
            user_id: User ID to which the personal emergency address belongs.
            level: The emergency address owner level:  * `0` - Account/Company-level emergency address.   * `1` - User/Personal-level emerg
            status: The emergency address verification status:  * `1` &mdash; Verification not Required.  * `2` &mdash; Unverified.  * `3` &
            address_keyword: Keyword(s) to filter emergency addresses. You can filter by either:  * Address Line 1.  * Address Line 2.  * City.  * St
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            page_size: The number of records returned within a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if site_id is not None:
            query_params['site_id'] = site_id
        if user_id is not None:
            query_params['user_id'] = user_id
        if level is not None:
            query_params['level'] = str(level)
        if status is not None:
            query_params['status'] = str(status)
        if address_keyword is not None:
            query_params['address_keyword'] = address_keyword
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/emergency_addresses"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_emergency_addresses" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_emergency_addresses")

    async def add_emergency_address(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add an emergency address

        HTTP POST /phone/emergency_addresses

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/emergency_addresses"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_emergency_address" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_emergency_address")

    async def get_emergency_address(
        self,
        emergencyAddressId: str
    ) -> ZoomResponse:
        """Get emergency address details

        HTTP GET /phone/emergency_addresses/{emergencyAddressId}

        Args:
            emergencyAddressId: The emergency address ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/emergency_addresses/{emergencyAddressId}".format(emergencyAddressId=emergencyAddressId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_emergency_address" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_emergency_address")

    async def delete_emergency_address(
        self,
        emergencyAddressId: str
    ) -> ZoomResponse:
        """Delete an emergency address

        HTTP DELETE /phone/emergency_addresses/{emergencyAddressId}

        Args:
            emergencyAddressId: The emergency address ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/emergency_addresses/{emergencyAddressId}".format(emergencyAddressId=emergencyAddressId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_emergency_address" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_emergency_address")

    async def update_emergency_address(
        self,
        emergencyAddressId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update an emergency address

        HTTP PATCH /phone/emergency_addresses/{emergencyAddressId}

        Args:
            emergencyAddressId: The ID of the emergency address.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/emergency_addresses/{emergencyAddressId}".format(emergencyAddressId=emergencyAddressId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_emergency_address" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_emergency_address")

    async def batch_add_locations(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Batch add emergency service locations

        HTTP POST /phone/batch_locations

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/batch_locations"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed batch_add_locations" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute batch_add_locations")

    async def list_locations(
        self,
        next_page_token: str | None = None,
        page_size: int | None = None,
        site_id: str | None = None
    ) -> ZoomResponse:
        """List emergency service locations

        HTTP GET /phone/locations

        Args:
            next_page_token: The next page token paginates through large result sets. A next page token returns whenever the set of available results
            page_size: The number of records returned within a single API call.
            site_id: The unique identifier of the site. It can be retrieved from the [List Phone Sites](https://marketplace.zoom.us/docs/api-

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if site_id is not None:
            query_params['site_id'] = site_id

        url = self.base_url + "/phone/locations"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_locations" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_locations")

    async def add_location(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add an emergency service location

        HTTP POST /phone/locations

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/locations"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_location" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_location")

    async def get_location(
        self,
        locationId: str
    ) -> ZoomResponse:
        """Get emergency service location details

        HTTP GET /phone/locations/{locationId}

        Args:
            locationId: The emergency service location's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/locations/{locationId}".format(locationId=locationId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_location" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_location")

    async def delete_location(
        self,
        locationId: str
    ) -> ZoomResponse:
        """Delete an emergency location

        HTTP DELETE /phone/locations/{locationId}

        Args:
            locationId: The emergency service location's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/locations/{locationId}".format(locationId=locationId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_location" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_location")

    async def update_location(
        self,
        locationId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update emergency service location

        HTTP PATCH /phone/locations/{locationId}

        Args:
            locationId: The emergency service location's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/locations/{locationId}".format(locationId=locationId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_location" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_location")

    async def list_external_contacts(
        self,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List external contacts

        HTTP GET /phone/external_contacts

        Args:
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            page_size: The number of records returned within a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/external_contacts"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_external_contacts" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_external_contacts")

    async def add_external_contact(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add an external contact

        HTTP POST /phone/external_contacts

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/external_contacts"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_external_contact" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_external_contact")

    async def get_a_external_contact(
        self,
        externalContactId: str
    ) -> ZoomResponse:
        """Get external contact details

        HTTP GET /phone/external_contacts/{externalContactId}

        Args:
            externalContactId: The external contact's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/external_contacts/{externalContactId}".format(externalContactId=externalContactId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_a_external_contact" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_a_external_contact")

    async def delete_a_external_contact(
        self,
        externalContactId: str
    ) -> ZoomResponse:
        """Delete an external contact

        HTTP DELETE /phone/external_contacts/{externalContactId}

        Args:
            externalContactId: The external contact's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/external_contacts/{externalContactId}".format(externalContactId=externalContactId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_a_external_contact" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_a_external_contact")

    async def update_external_contact(
        self,
        externalContactId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update external contact

        HTTP PATCH /phone/external_contacts/{externalContactId}

        Args:
            externalContactId: The external contact ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/external_contacts/{externalContactId}".format(externalContactId=externalContactId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_external_contact" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_external_contact")

    async def getuser_sfaxlogs(
        self,
        extensionId: str,
        page_size: int | None = None,
        next_page_token: str | None = None,
        sender_number: str | None = None,
        receiver_number: str | None = None
    ) -> ZoomResponse:
        """Get extension's fax logs

        HTTP GET /phone/extension/{extensionId}/fax/logs

        Args:
            extensionId: The extension ID of the fax log owner.
            page_size: The number of records returned within a single API call.  The default is **30** and the maximum is **300**.
            next_page_token: The token to retrieve the next page of results.
            sender_number: ThesSender's fax number in E164 format.
            receiver_number: The receiver's fax number in E164 format.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if sender_number is not None:
            query_params['sender_number'] = sender_number
        if receiver_number is not None:
            query_params['receiver_number'] = receiver_number

        url = self.base_url + "/phone/extension/{extensionId}/fax/logs".format(extensionId=extensionId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getuser_sfaxlogs" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getuser_sfaxlogs")

    async def get_account_s_fax_logs(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        site_id: str | None = None,
        sender_number: str | None = None,
        receiver_number: str | None = None,
        extension_type: str | None = None
    ) -> ZoomResponse:
        """Get account's fax logs

        HTTP GET /phone/fax/logs

        Args:
            page_size: The number of records returned within a single API call.  The default is **30** and the maximum is **300**.
            next_page_token: The token to retrieve the next page of results.
            site_id: The site's unique ID.
            sender_number: The sender's fax number in E164 format.
            receiver_number: The receiver's fax number in E164 format.
            extension_type: The extension type of fax's log owner.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if site_id is not None:
            query_params['site_id'] = site_id
        if sender_number is not None:
            query_params['sender_number'] = sender_number
        if receiver_number is not None:
            query_params['receiver_number'] = receiver_number
        if extension_type is not None:
            query_params['extension_type'] = extension_type

        url = self.base_url + "/phone/fax/logs"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_account_s_fax_logs" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_account_s_fax_logs")

    async def get_fax_log_details(
        self,
        faxLogId: str
    ) -> ZoomResponse:
        """Get fax log details

        HTTP GET /phone/fax/logs/{faxLogId}

        Args:
            faxLogId: The fax log's unique ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/fax/logs/{faxLogId}".format(faxLogId=faxLogId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_fax_log_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_fax_log_details")

    async def downloadfaxfile(
        self,
        faxLogId: str,
        fileId: str
    ) -> ZoomResponse:
        """Download fax file

        HTTP GET /phone/fax/logs/{faxLogId}/file/{fileId}

        Args:
            faxLogId: The fax log's unique ID.
            fileId: The fax file ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/fax/logs/{faxLogId}/file/{fileId}".format(faxLogId=faxLogId, fileId=fileId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed downloadfaxfile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute downloadfaxfile")

    async def list_firmware_rules(
        self,
        site_id: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List firmware update rules

        HTTP GET /phone/firmware_update_rules

        Args:
            site_id: Unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-multiple-sites). Require
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if site_id is not None:
            query_params['site_id'] = site_id
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/firmware_update_rules"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_firmware_rules" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_firmware_rules")

    async def add_firmware_rule(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a firmware update rule

        HTTP POST /phone/firmware_update_rules

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/firmware_update_rules"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_firmware_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_firmware_rule")

    async def get_firmware_rule_detail(
        self,
        ruleId: str
    ) -> ZoomResponse:
        """Get firmware update rule information

        HTTP GET /phone/firmware_update_rules/{ruleId}

        Args:
            ruleId: Unique identifier of the firmware update rule.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/firmware_update_rules/{ruleId}".format(ruleId=ruleId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_firmware_rule_detail" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_firmware_rule_detail")

    async def delete_firmware_update_rule(
        self,
        ruleId: str,
        restart_type: int | None = None
    ) -> ZoomResponse:
        """Delete firmware update rule

        HTTP DELETE /phone/firmware_update_rules/{ruleId}

        Args:
            ruleId: Unique identifier of the firmware update rule.
            restart_type: Restart type: `1` - Restart the devices immediately. `2` - Restart with the next resync or auto pull.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if restart_type is not None:
            query_params['restart_type'] = str(restart_type)

        url = self.base_url + "/phone/firmware_update_rules/{ruleId}".format(ruleId=ruleId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_firmware_update_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_firmware_update_rule")

    async def update_firmware_rule(
        self,
        ruleId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update firmware update rule

        HTTP PATCH /phone/firmware_update_rules/{ruleId}

        Args:
            ruleId: Unique identifier of the firmware update rule.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/firmware_update_rules/{ruleId}".format(ruleId=ruleId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_firmware_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_firmware_rule")

    async def list_firmwares(
        self,
        *,
        is_update: bool | None = None,
        site_id: str | None = None
    ) -> ZoomResponse:
        """List updatable firmwares

        HTTP GET /phone/firmwares

        Args:
            is_update: Firmware update rule enabled.   `true` - Get all firmwares that can have firmware update rules added   `false` - Get all
            site_id: Unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-multiple-sites). Require

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if is_update is not None:
            query_params['is_update'] = str(is_update).lower()
        if site_id is not None:
            query_params['site_id'] = site_id

        url = self.base_url + "/phone/firmwares"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_firmwares" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_firmwares")

    async def list_gcp(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        site_id: str | None = None
    ) -> ZoomResponse:
        """List group call pickup objects

        HTTP GET /phone/group_call_pickup

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            site_id: Unique identifier of the site. This can be retrieved from the [List Phone Sites](https://marketplace.zoom.us/docs/api-re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if site_id is not None:
            query_params['site_id'] = site_id

        url = self.base_url + "/phone/group_call_pickup"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_gcp" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_gcp")

    async def add_gcp(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a group call pickup object

        HTTP POST /phone/group_call_pickup

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/group_call_pickup"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_gcp" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_gcp")

    async def get_gcp(
        self,
        groupId: str
    ) -> ZoomResponse:
        """Get call pickup group by ID

        HTTP GET /phone/group_call_pickup/{groupId}

        Args:
            groupId: Path parameter

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/group_call_pickup/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_gcp" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_gcp")

    async def delete_gcp(
        self,
        groupId: str
    ) -> ZoomResponse:
        """Delete group call pickup objects

        HTTP DELETE /phone/group_call_pickup/{groupId}

        Args:
            groupId: Path parameter

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/group_call_pickup/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_gcp" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_gcp")

    async def update_gcp(
        self,
        groupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update the group call pickup information

        HTTP PATCH /phone/group_call_pickup/{groupId}

        Args:
            groupId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/group_call_pickup/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_gcp" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_gcp")

    async def list_gcp_members(
        self,
        groupId: str,
        page_size: int | None = None,
        next_page_token: str | None = None,
        site_id: str | None = None,
        extension_type: str | None = None
    ) -> ZoomResponse:
        """List call pickup group members

        HTTP GET /phone/group_call_pickup/{groupId}/members

        Args:
            groupId: Path parameter
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            site_id: Unique identifier of the site.
            extension_type: Type of the assignee.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if site_id is not None:
            query_params['site_id'] = site_id
        if extension_type is not None:
            query_params['extension_type'] = extension_type

        url = self.base_url + "/phone/group_call_pickup/{groupId}/members".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_gcp_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_gcp_members")

    async def add_gcp_members(
        self,
        groupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add members to a call pickup group

        HTTP POST /phone/group_call_pickup/{groupId}/members

        Args:
            groupId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/group_call_pickup/{groupId}/members".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_gcp_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_gcp_members")

    async def remove_gcp_members(
        self,
        groupId: str,
        extensionId: str
    ) -> ZoomResponse:
        """Remove members from call pickup group

        HTTP DELETE /phone/group_call_pickup/{groupId}/members/{extensionId}

        Args:
            groupId: Path parameter
            extensionId: Path parameter

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/group_call_pickup/{groupId}/members/{extensionId}".format(groupId=groupId, extensionId=extensionId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed remove_gcp_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute remove_gcp_members")

    async def get_group_policy_details(
        self,
        groupId: str,
        policyType: str
    ) -> ZoomResponse:
        """Get group policy details

        HTTP GET /phone/groups/{groupId}/policies/{policyType}

        Args:
            groupId: The user group ID.
            policyType: This field specifies the policy type to retrieve or modify. See the documentation for detailed behavior of each policy t

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/groups/{groupId}/policies/{policyType}".format(groupId=groupId, policyType=policyType)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_group_policy_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_group_policy_details")

    async def update_group_policy(
        self,
        groupId: str,
        policyType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update group policy

        HTTP PATCH /phone/groups/{groupId}/policies/{policyType}

        Args:
            groupId: The user group ID.
            policyType: This field specifies the policy type to retrieve or modify. See the documentation for detailed behavior of each policy t
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/groups/{groupId}/policies/{policyType}".format(groupId=groupId, policyType=policyType)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_group_policy" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_group_policy")

    async def get_group_phone_settings(
        self,
        groupId: str,
        setting_types: str | None = None
    ) -> ZoomResponse:
        """Get group phone settings

        HTTP GET /phone/groups/{groupId}/settings

        Args:
            groupId: The group ID.   It can be retrieved from the [List groups](/docs/api/rest/reference/zoom-api/methods/#operation/groups)
            setting_types: This setting corresponds to the setting item you want to modify.   Comma separated.   **Allowed values** * `call_live_tr

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if setting_types is not None:
            query_params['setting_types'] = setting_types

        url = self.base_url + "/phone/groups/{groupId}/settings".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_group_phone_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_group_phone_settings")

    async def get_auto_receptionist_ivr(
        self,
        autoReceptionistId: str,
        hours_type: str | None = None,
        holiday_id: str | None = None
    ) -> ZoomResponse:
        """Get auto receptionist IVR

        HTTP GET /phone/auto_receptionists/{autoReceptionistId}/ivr

        Args:
            autoReceptionistId: The unique identifier of the auto receptionist. It can be retrieved from the [List Phone Sites](https://marketplace.zoom
            hours_type: The query hours type: `business_hours` or `closed_hours`, default `business_hours`.
            holiday_id: The auto receptionist holiday hours ID. If both `holiday_id` and `hours_type` are passed, `holiday_id` has a high priori

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if hours_type is not None:
            query_params['hours_type'] = hours_type
        if holiday_id is not None:
            query_params['holiday_id'] = holiday_id

        url = self.base_url + "/phone/auto_receptionists/{autoReceptionistId}/ivr".format(autoReceptionistId=autoReceptionistId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_auto_receptionist_ivr" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_auto_receptionist_ivr")

    async def update_auto_receptionist_ivr(
        self,
        autoReceptionistId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update auto receptionist IVR

        HTTP PATCH /phone/auto_receptionists/{autoReceptionistId}/ivr

        Args:
            autoReceptionistId: The auto receptionist id.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/auto_receptionists/{autoReceptionistId}/ivr".format(autoReceptionistId=autoReceptionistId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_auto_receptionist_ivr" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_auto_receptionist_ivr")

    async def list_extension_level_inbound_block_rules(
        self,
        extensionId: str,
        keyword: str | None = None,
        match_type: str | None = None,
        type_: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List an extension's inbound block rules

        HTTP GET /phone/extension/{extensionId}/inbound_blocked/rules

        Args:
            extensionId: The extension ID for the inbound blocked rules to fetch.
            keyword: The partial string of a phone number.
            match_type: The match type for the block rule: * `phoneNumber`: Only a specific phone number that is shown in the `blocked_number` f
            type_: The block type for the block rule: * `block_for_other_reasons` * `block_as_threat`
            next_page_token: The next page token paginates through a large set of results. It returns whenever the set of available results exceeds t
            page_size: The number of records in a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if keyword is not None:
            query_params['keyword'] = keyword
        if match_type is not None:
            query_params['match_type'] = match_type
        if type_ is not None:
            query_params['type'] = type_
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/extension/{extensionId}/inbound_blocked/rules".format(extensionId=extensionId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_extension_level_inbound_block_rules" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_extension_level_inbound_block_rules")

    async def add_extensiont_level_inbound_block_rules(
        self,
        extensionId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add an extension's inbound block rule

        HTTP POST /phone/extension/{extensionId}/inbound_blocked/rules

        Args:
            extensionId: The extension ID for the inbound blocked rules to fetch.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/extension/{extensionId}/inbound_blocked/rules".format(extensionId=extensionId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_extensiont_level_inbound_block_rules" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_extensiont_level_inbound_block_rules")

    async def delete_extensiont_level_inbound_block_rules(
        self,
        extensionId: str,
        blocked_rule_id: str | None = None
    ) -> ZoomResponse:
        """Delete an extension's inbound block rule

        HTTP DELETE /phone/extension/{extensionId}/inbound_blocked/rules

        Args:
            extensionId: The extension ID for the inbound blocked rules to fetch.
            blocked_rule_id: The unique identifier of the blocked rule.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if blocked_rule_id is not None:
            query_params['blocked_rule_id'] = blocked_rule_id

        url = self.base_url + "/phone/extension/{extensionId}/inbound_blocked/rules".format(extensionId=extensionId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_extensiont_level_inbound_block_rules" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_extensiont_level_inbound_block_rules")

    async def list_account_level_inbound_blocked_statistics(
        self,
        keyword: str | None = None,
        match_type: str | None = None,
        type_: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List an account's inbound blocked statistics

        HTTP GET /phone/inbound_blocked/extension_rules/statistics

        Args:
            keyword: The partial string of a phone number.
            match_type: The match type for the block rule: * `phoneNumber`: Only a specific phone number that is shown in the `blocked_number` f
            type_: The block type for the block rule: * block_for_other_reasons * block_as_threat
            next_page_token: The next page token paginates through a large set of results. It returns whenever the set of available results exceeds t
            page_size: The number of records in a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if keyword is not None:
            query_params['keyword'] = keyword
        if match_type is not None:
            query_params['match_type'] = match_type
        if type_ is not None:
            query_params['type'] = type_
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/inbound_blocked/extension_rules/statistics"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_account_level_inbound_blocked_statistics" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_account_level_inbound_blocked_statistics")

    async def delete_account_level_inbound_blocked_statistics(
        self,
        blocked_statistic_id: str | None = None
    ) -> ZoomResponse:
        """Delete an account's inbound blocked statistics

        HTTP DELETE /phone/inbound_blocked/extension_rules/statistics

        Args:
            blocked_statistic_id: The unique identifier of the blocked statistic.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if blocked_statistic_id is not None:
            query_params['blocked_statistic_id'] = blocked_statistic_id

        url = self.base_url + "/phone/inbound_blocked/extension_rules/statistics"

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_account_level_inbound_blocked_statistics" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_account_level_inbound_blocked_statistics")

    async def mark_phone_number_as_blocked_for_all_extensions(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Mark a phone number as blocked for all extensions

        HTTP PATCH /phone/inbound_blocked/extension_rules/statistics/blocked_for_all

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/inbound_blocked/extension_rules/statistics/blocked_for_all"

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed mark_phone_number_as_blocked_for_all_extensions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute mark_phone_number_as_blocked_for_all_extensions")

    async def list_account_level_inbound_block_rules(
        self,
        keyword: str | None = None,
        match_type: str | None = None,
        type_: str | None = None,
        status: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List an account's inbound block rules

        HTTP GET /phone/inbound_blocked/rules

        Args:
            keyword: The partial string of a phone number.
            match_type: The match type for the block rule: * `phoneNumber`: Indicates that only a specific phone number that is shown in the `bl
            type_: The block type for the block rule: * block_for_other_reasons * block_as_threat
            status: Whether the block rule is active or inactive. * `active`: The block rule is active. * `inactive`: The block rule is inac
            next_page_token: The next page token paginates through a large set of results. It returns whenever the set of available results exceeds t
            page_size: The number of records in a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if keyword is not None:
            query_params['keyword'] = keyword
        if match_type is not None:
            query_params['match_type'] = match_type
        if type_ is not None:
            query_params['type'] = type_
        if status is not None:
            query_params['status'] = status
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/inbound_blocked/rules"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_account_level_inbound_block_rules" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_account_level_inbound_block_rules")

    async def add_account_level_inbound_block_rules(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add an account's inbound block rule

        HTTP POST /phone/inbound_blocked/rules

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/inbound_blocked/rules"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_account_level_inbound_block_rules" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_account_level_inbound_block_rules")

    async def delete_account_level_inbound_block_rules(
        self,
        blocked_rule_id: str | None = None
    ) -> ZoomResponse:
        """Delete an account's inbound block rule

        HTTP DELETE /phone/inbound_blocked/rules

        Args:
            blocked_rule_id: The unique identifier of the blocked rule.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if blocked_rule_id is not None:
            query_params['blocked_rule_id'] = blocked_rule_id

        url = self.base_url + "/phone/inbound_blocked/rules"

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_account_level_inbound_block_rules" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_account_level_inbound_block_rules")

    async def update_account_level_inbound_block_rule(
        self,
        blockedRuleId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update an account's inbound block rule

        HTTP PATCH /phone/inbound_blocked/rules/{blockedRuleId}

        Args:
            blockedRuleId: The unique identifier of the blocked rule.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/inbound_blocked/rules/{blockedRuleId}".format(blockedRuleId=blockedRuleId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_account_level_inbound_block_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_account_level_inbound_block_rule")

    async def list_line_key_setting(
        self,
        extensionId: str
    ) -> ZoomResponse:
        """Get line key position and settings information

        HTTP GET /phone/extension/{extensionId}/line_keys

        Args:
            extensionId: The extension ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/extension/{extensionId}/line_keys".format(extensionId=extensionId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_line_key_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_line_key_setting")

    async def batch_update_line_key_setting(
        self,
        extensionId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Batch update line key position and settings information

        HTTP PATCH /phone/extension/{extensionId}/line_keys

        Args:
            extensionId: The extension ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/extension/{extensionId}/line_keys".format(extensionId=extensionId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed batch_update_line_key_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute batch_update_line_key_setting")

    async def delete_line_key(
        self,
        extensionId: str,
        lineKeyId: str
    ) -> ZoomResponse:
        """Delete a line key setting.

        HTTP DELETE /phone/extension/{extensionId}/line_keys/{lineKeyId}

        Args:
            extensionId: The extension ID.
            lineKeyId: Line key ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/extension/{extensionId}/line_keys/{lineKeyId}".format(extensionId=extensionId, lineKeyId=lineKeyId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_line_key" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_line_key")

    async def list_monitoring_group(
        self,
        type_: int | None = None,
        site_id: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get a list of monitoring groups on an account

        HTTP GET /phone/monitoring_groups

        Args:
            type_: The monitoring group's type.
            site_id: The unique identifier of the monitoring group's site.
            page_size: The size of the page.
            next_page_token: The current page number of returned records.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = str(type_)
        if site_id is not None:
            query_params['site_id'] = site_id
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/monitoring_groups"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_monitoring_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_monitoring_group")

    async def create_monitoring_group(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a monitoring group

        HTTP POST /phone/monitoring_groups

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/monitoring_groups"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_monitoring_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_monitoring_group")

    async def get_monitoring_group_by_id(
        self,
        monitoringGroupId: str
    ) -> ZoomResponse:
        """Get monitoring group by ID

        HTTP GET /phone/monitoring_groups/{monitoringGroupId}

        Args:
            monitoringGroupId: The monitoring group ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/monitoring_groups/{monitoringGroupId}".format(monitoringGroupId=monitoringGroupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_monitoring_group_by_id" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_monitoring_group_by_id")

    async def delete_monitoring_group(
        self,
        monitoringGroupId: str
    ) -> ZoomResponse:
        """Delete a monitoring group

        HTTP DELETE /phone/monitoring_groups/{monitoringGroupId}

        Args:
            monitoringGroupId: Monitoring group ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/monitoring_groups/{monitoringGroupId}".format(monitoringGroupId=monitoringGroupId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_monitoring_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_monitoring_group")

    async def update_monitoring_group(
        self,
        monitoringGroupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a monitoring group

        HTTP PATCH /phone/monitoring_groups/{monitoringGroupId}

        Args:
            monitoringGroupId: Monitoring group ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/monitoring_groups/{monitoringGroupId}".format(monitoringGroupId=monitoringGroupId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_monitoring_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_monitoring_group")

    async def list_members(
        self,
        monitoringGroupId: str,
        member_type: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get members of a monitoring group

        HTTP GET /phone/monitoring_groups/{monitoringGroupId}/monitor_members

        Args:
            monitoringGroupId: Monitoring group ID.
            member_type: Member type
            page_size: The size of the page.
            next_page_token: The current page number of returned records.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if member_type is not None:
            query_params['member_type'] = member_type
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/monitoring_groups/{monitoringGroupId}/monitor_members".format(monitoringGroupId=monitoringGroupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_members")

    async def add_members(
        self,
        monitoringGroupId: str,
        body: dict[str, Any],
        member_type: str | None = None
    ) -> ZoomResponse:
        """Add members to a monitoring group

        HTTP POST /phone/monitoring_groups/{monitoringGroupId}/monitor_members

        Args:
            monitoringGroupId: Monitoring group ID.
            body: Request body payload
            member_type: Member type

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if member_type is not None:
            query_params['member_type'] = member_type

        url = self.base_url + "/phone/monitoring_groups/{monitoringGroupId}/monitor_members".format(monitoringGroupId=monitoringGroupId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_members")

    async def remove_members(
        self,
        monitoringGroupId: str,
        member_type: str | None = None
    ) -> ZoomResponse:
        """Remove all monitors or monitored members from a monitoring group

        HTTP DELETE /phone/monitoring_groups/{monitoringGroupId}/monitor_members

        Args:
            monitoringGroupId: Monitoring group ID.
            member_type: Member type

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if member_type is not None:
            query_params['member_type'] = member_type

        url = self.base_url + "/phone/monitoring_groups/{monitoringGroupId}/monitor_members".format(monitoringGroupId=monitoringGroupId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed remove_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute remove_members")

    async def remove_member(
        self,
        monitoringGroupId: str,
        memberExtensionId: str,
        member_type: str | None = None
    ) -> ZoomResponse:
        """Remove a member from a monitoring group

        HTTP DELETE /phone/monitoring_groups/{monitoringGroupId}/monitor_members/{memberExtensionId}

        Args:
            monitoringGroupId: Monitoring group ID.
            memberExtensionId: Member's extension ID.
            member_type: Member type

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if member_type is not None:
            query_params['member_type'] = member_type

        url = self.base_url + "/phone/monitoring_groups/{monitoringGroupId}/monitor_members/{memberExtensionId}".format(monitoringGroupId=monitoringGroupId, memberExtensionId=memberExtensionId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed remove_member" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute remove_member")

    async def get_common_area_outbound_calling_countries_and_regions(
        self,
        commonAreaId: str,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """Get common area level outbound calling countries and regions

        HTTP GET /phone/common_areas/{commonAreaId}/outbound_calling/countries_regions

        Args:
            commonAreaId: The ID of the common area.
            next_page_token: The next page token paginates through a large set of results. It returns whenever the set of available results exceeds t
            page_size: The number of records in a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/common_areas/{commonAreaId}/outbound_calling/countries_regions".format(commonAreaId=commonAreaId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_common_area_outbound_calling_countries_and_regions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_common_area_outbound_calling_countries_and_regions")

    async def update_common_area_outbound_calling_countries_or_regions(
        self,
        commonAreaId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update common area level outbound calling countries or regions

        HTTP PATCH /phone/common_areas/{commonAreaId}/outbound_calling/countries_regions

        Args:
            commonAreaId: The ID of the common area.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/{commonAreaId}/outbound_calling/countries_regions".format(commonAreaId=commonAreaId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_common_area_outbound_calling_countries_or_regions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_common_area_outbound_calling_countries_or_regions")

    async def list_common_area_outbound_calling_exception_rule(
        self,
        commonAreaId: str,
        country: str | None = None,
        keyword: str | None = None,
        match_type: str | None = None,
        status: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List common area level outbound calling exception rules

        HTTP GET /phone/common_areas/{commonAreaId}/outbound_calling/exception_rules

        Args:
            commonAreaId: The ID of the common area.
            country: The [country ISO code](https://marketplace.zoom.us/docs/api-reference/other-references/abbreviation-lists#countries).
            keyword: The partial string of a phone number.
            match_type: The match type of an exception rule.
            status: The status of an exception rule.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            page_size: The number of records in a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if country is not None:
            query_params['country'] = country
        if keyword is not None:
            query_params['keyword'] = keyword
        if match_type is not None:
            query_params['match_type'] = match_type
        if status is not None:
            query_params['status'] = status
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/common_areas/{commonAreaId}/outbound_calling/exception_rules".format(commonAreaId=commonAreaId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_common_area_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_common_area_outbound_calling_exception_rule")

    async def add_common_area_outbound_calling_exception_rule(
        self,
        commonAreaId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add common area level outbound calling exception rule

        HTTP POST /phone/common_areas/{commonAreaId}/outbound_calling/exception_rules

        Args:
            commonAreaId: The ID of the common area.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/{commonAreaId}/outbound_calling/exception_rules".format(commonAreaId=commonAreaId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_common_area_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_common_area_outbound_calling_exception_rule")

    async def delete_common_area_outbound_calling_exception_rule(
        self,
        commonAreaId: str,
        exceptionRuleId: str
    ) -> ZoomResponse:
        """Delete common area level outbound calling exception rule

        HTTP DELETE /phone/common_areas/{commonAreaId}/outbound_calling/exception_rules/{exceptionRuleId}

        Args:
            commonAreaId: The ID of the common area.
            exceptionRuleId: The exception rule ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/{commonAreaId}/outbound_calling/exception_rules/{exceptionRuleId}".format(commonAreaId=commonAreaId, exceptionRuleId=exceptionRuleId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_common_area_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_common_area_outbound_calling_exception_rule")

    async def update_common_area_outbound_calling_exception_rule(
        self,
        commonAreaId: str,
        exceptionRuleId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update common area level outbound calling exception rule

        HTTP PATCH /phone/common_areas/{commonAreaId}/outbound_calling/exception_rules/{exceptionRuleId}

        Args:
            commonAreaId: The ID of the common area.
            exceptionRuleId: The exception rule ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/common_areas/{commonAreaId}/outbound_calling/exception_rules/{exceptionRuleId}".format(commonAreaId=commonAreaId, exceptionRuleId=exceptionRuleId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_common_area_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_common_area_outbound_calling_exception_rule")

    async def get_account_outbound_calling_countries_and_regions(
        self,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """Get account level outbound calling countries and regions

        HTTP GET /phone/outbound_calling/countries_regions

        Args:
            next_page_token: The next page token paginates through a large set of results. It returns whenever the set of available results exceeds t
            page_size: The number of records in a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/outbound_calling/countries_regions"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_account_outbound_calling_countries_and_regions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_account_outbound_calling_countries_and_regions")

    async def update_account_outbound_calling_countries_or_regions(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update account level outbound calling countries or regions

        HTTP PATCH /phone/outbound_calling/countries_regions

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/outbound_calling/countries_regions"

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_account_outbound_calling_countries_or_regions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_account_outbound_calling_countries_or_regions")

    async def list_account_outbound_calling_exception_rule(
        self,
        country: str | None = None,
        keyword: str | None = None,
        match_type: str | None = None,
        status: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List account level outbound calling exception rules

        HTTP GET /phone/outbound_calling/exception_rules

        Args:
            country: The [country ISO code](https://marketplace.zoom.us/docs/api-reference/other-references/abbreviation-lists#countries).
            keyword: The partial string of a phone number.
            match_type: The match type of an exception rule.
            status: The status of an exception rule.
            next_page_token: The next page token paginates through a large set of results. It returns whenever the set of available results exceeds t
            page_size: The number of records in a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if country is not None:
            query_params['country'] = country
        if keyword is not None:
            query_params['keyword'] = keyword
        if match_type is not None:
            query_params['match_type'] = match_type
        if status is not None:
            query_params['status'] = status
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/outbound_calling/exception_rules"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_account_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_account_outbound_calling_exception_rule")

    async def add_account_outbound_calling_exception_rule(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add account level outbound calling exception rule

        HTTP POST /phone/outbound_calling/exception_rules

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/outbound_calling/exception_rules"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_account_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_account_outbound_calling_exception_rule")

    async def delete_account_outbound_calling_exception_rule(
        self,
        exceptionRuleId: str
    ) -> ZoomResponse:
        """Delete account level outbound calling exception rule

        HTTP DELETE /phone/outbound_calling/exception_rules/{exceptionRuleId}

        Args:
            exceptionRuleId: The exception rule ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/outbound_calling/exception_rules/{exceptionRuleId}".format(exceptionRuleId=exceptionRuleId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_account_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_account_outbound_calling_exception_rule")

    async def update_account_outbound_calling_exception_rule(
        self,
        exceptionRuleId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update account level outbound calling exception rule

        HTTP PATCH /phone/outbound_calling/exception_rules/{exceptionRuleId}

        Args:
            exceptionRuleId: The exception rule ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/outbound_calling/exception_rules/{exceptionRuleId}".format(exceptionRuleId=exceptionRuleId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_account_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_account_outbound_calling_exception_rule")

    async def get_site_outbound_calling_countries_and_regions(
        self,
        siteId: str,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """Get site level outbound calling countries and regions

        HTTP GET /phone/sites/{siteId}/outbound_calling/countries_regions

        Args:
            siteId: The ID of the site.
            next_page_token: The next page token paginates through a large set of results. It returns whenever the set of available results exceeds t
            page_size: The number of records in a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/sites/{siteId}/outbound_calling/countries_regions".format(siteId=siteId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_site_outbound_calling_countries_and_regions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_site_outbound_calling_countries_and_regions")

    async def update_site_outbound_calling_countries_or_regions(
        self,
        siteId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update site level outbound calling countries or regions

        HTTP PATCH /phone/sites/{siteId}/outbound_calling/countries_regions

        Args:
            siteId: The ID of the site.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sites/{siteId}/outbound_calling/countries_regions".format(siteId=siteId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_site_outbound_calling_countries_or_regions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_site_outbound_calling_countries_or_regions")

    async def list_site_outbound_calling_exception_rule(
        self,
        siteId: str,
        country: str | None = None,
        keyword: str | None = None,
        match_type: str | None = None,
        status: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List site level outbound calling exception rules

        HTTP GET /phone/sites/{siteId}/outbound_calling/exception_rules

        Args:
            siteId: The ID of the site.
            country: The [country ISO code](https://marketplace.zoom.us/docs/api-reference/other-references/abbreviation-lists#countries).
            keyword: The partial string of a phone number.
            match_type: The match type of an exception rule.
            status: The status of an exception rule.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            page_size: The number of records in a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if country is not None:
            query_params['country'] = country
        if keyword is not None:
            query_params['keyword'] = keyword
        if match_type is not None:
            query_params['match_type'] = match_type
        if status is not None:
            query_params['status'] = status
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/sites/{siteId}/outbound_calling/exception_rules".format(siteId=siteId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_site_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_site_outbound_calling_exception_rule")

    async def add_site_outbound_calling_exception_rule(
        self,
        siteId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add site level outbound calling exception rule

        HTTP POST /phone/sites/{siteId}/outbound_calling/exception_rules

        Args:
            siteId: The ID of the site.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sites/{siteId}/outbound_calling/exception_rules".format(siteId=siteId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_site_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_site_outbound_calling_exception_rule")

    async def delete_site_outbound_calling_exception_rule(
        self,
        siteId: str,
        exceptionRuleId: str
    ) -> ZoomResponse:
        """Delete site level outbound calling exception rule

        HTTP DELETE /phone/sites/{siteId}/outbound_calling/exception_rules/{exceptionRuleId}

        Args:
            siteId: The ID of the site.
            exceptionRuleId: The exception rule ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sites/{siteId}/outbound_calling/exception_rules/{exceptionRuleId}".format(siteId=siteId, exceptionRuleId=exceptionRuleId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_site_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_site_outbound_calling_exception_rule")

    async def update_site_outbound_calling_exception_rule(
        self,
        siteId: str,
        exceptionRuleId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update site level outbound calling exception rule

        HTTP PATCH /phone/sites/{siteId}/outbound_calling/exception_rules/{exceptionRuleId}

        Args:
            siteId: The ID of the site.
            exceptionRuleId: The exception rule ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sites/{siteId}/outbound_calling/exception_rules/{exceptionRuleId}".format(siteId=siteId, exceptionRuleId=exceptionRuleId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_site_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_site_outbound_calling_exception_rule")

    async def get_user_outbound_calling_countries_and_regions(
        self,
        userId: str,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """Get user level outbound calling countries and regions

        HTTP GET /phone/users/{userId}/outbound_calling/countries_regions

        Args:
            userId: The ID of the user.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            page_size: The number of records in a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/users/{userId}/outbound_calling/countries_regions".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_user_outbound_calling_countries_and_regions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_user_outbound_calling_countries_and_regions")

    async def update_user_outbound_calling_countries_or_regions(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update user level outbound calling countries or regions

        HTTP PATCH /phone/users/{userId}/outbound_calling/countries_regions

        Args:
            userId: The ID of the user.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/outbound_calling/countries_regions".format(userId=userId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_user_outbound_calling_countries_or_regions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_user_outbound_calling_countries_or_regions")

    async def list_user_outbound_calling_exception_rule(
        self,
        userId: str,
        country: str | None = None,
        keyword: str | None = None,
        match_type: str | None = None,
        status: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List user level outbound calling exception rules

        HTTP GET /phone/users/{userId}/outbound_calling/exception_rules

        Args:
            userId: The ID of the user.
            country: The [country ISO code](https://marketplace.zoom.us/docs/api-reference/other-references/abbreviation-lists#countries).
            keyword: The partial string of a phone number.
            match_type: The match type of an exception rule.
            status: The status of an exception rule.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            page_size: The number of records in a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if country is not None:
            query_params['country'] = country
        if keyword is not None:
            query_params['keyword'] = keyword
        if match_type is not None:
            query_params['match_type'] = match_type
        if status is not None:
            query_params['status'] = status
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/users/{userId}/outbound_calling/exception_rules".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_user_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_user_outbound_calling_exception_rule")

    async def add_user_outbound_calling_exception_rule(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add user level outbound calling exception rule

        HTTP POST /phone/users/{userId}/outbound_calling/exception_rules

        Args:
            userId: The ID of the user
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/outbound_calling/exception_rules".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_user_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_user_outbound_calling_exception_rule")

    async def delete_user_outbound_calling_exception_rule(
        self,
        userId: str,
        exceptionRuleId: str
    ) -> ZoomResponse:
        """Delete user level outbound calling exception rule

        HTTP DELETE /phone/users/{userId}/outbound_calling/exception_rules/{exceptionRuleId}

        Args:
            userId: The ID of the user.
            exceptionRuleId: The exception rule ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/outbound_calling/exception_rules/{exceptionRuleId}".format(userId=userId, exceptionRuleId=exceptionRuleId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_user_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_user_outbound_calling_exception_rule")

    async def update_user_outbound_calling_exception_rule(
        self,
        userId: str,
        exceptionRuleId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update user level outbound calling exception rule

        HTTP PATCH /phone/users/{userId}/outbound_calling/exception_rules/{exceptionRuleId}

        Args:
            userId: The ID of the user.
            exceptionRuleId: The exception rule ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/outbound_calling/exception_rules/{exceptionRuleId}".format(userId=userId, exceptionRuleId=exceptionRuleId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_user_outbound_calling_exception_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_user_outbound_calling_exception_rule")

    async def list_phone_devices(
        self,
        type_: str | None = None,
        assignee_type: str | None = None,
        device_source: str | None = None,
        location_status: str | None = None,
        site_id: str | None = None,
        device_type: str | None = None,
        keyword: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List devices

        HTTP GET /phone/devices

        Args:
            type_: The device status: `assigned` or `unassigned` to list device status in Zoom account.
            assignee_type: The type of the assignee. It's available if `type = assigned`. It's unavailable if the account has not enabled the commo
            device_source: The device source. `hotDesking` is only available when `type = assigned`.
            location_status: The status of device location. It's available if `type = assigned`.
            site_id: The site of the assignee.
            device_type: The manufacturer name or device type.
            keyword: The user, extension, MAC address, or IP address to filter the results.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            page_size: The number of records returned within a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if assignee_type is not None:
            query_params['assignee_type'] = assignee_type
        if device_source is not None:
            query_params['device_source'] = device_source
        if location_status is not None:
            query_params['location_status'] = location_status
        if site_id is not None:
            query_params['site_id'] = site_id
        if device_type is not None:
            query_params['device_type'] = device_type
        if keyword is not None:
            query_params['keyword'] = keyword
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/devices"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_phone_devices" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_phone_devices")

    async def add_phone_device(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a device

        HTTP POST /phone/devices

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/devices"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_phone_device" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_phone_device")

    async def sync_phone_device(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Sync deskphones

        HTTP POST /phone/devices/sync

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/devices/sync"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed sync_phone_device" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute sync_phone_device")

    async def get_a_device(
        self,
        deviceId: str
    ) -> ZoomResponse:
        """Get device details

        HTTP GET /phone/devices/{deviceId}

        Args:
            deviceId: The unique Identifier of the device.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/devices/{deviceId}".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_a_device" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_a_device")

    async def delete_a_device(
        self,
        deviceId: str
    ) -> ZoomResponse:
        """Delete a device

        HTTP DELETE /phone/devices/{deviceId}

        Args:
            deviceId: Unique identifier of the device.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/devices/{deviceId}".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_a_device" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_a_device")

    async def update_a_device(
        self,
        deviceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a device

        HTTP PATCH /phone/devices/{deviceId}

        Args:
            deviceId: The unique identifier of the device.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/devices/{deviceId}".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_a_device" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_a_device")

    async def add_extensions_to_a_device(
        self,
        deviceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign an entity to a device

        HTTP POST /phone/devices/{deviceId}/extensions

        Args:
            deviceId: Unique identifier of the device.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/devices/{deviceId}/extensions".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_extensions_to_a_device" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_extensions_to_a_device")

    async def delete_extension_from_a_device(
        self,
        deviceId: str,
        extensionId: str
    ) -> ZoomResponse:
        """Unassign an entity from the device

        HTTP DELETE /phone/devices/{deviceId}/extensions/{extensionId}

        Args:
            deviceId: Unique identifier of the device from which to unassign an assignee.
            extensionId: Extension ID of the assignee (`user` or `common area`)

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/devices/{deviceId}/extensions/{extensionId}".format(deviceId=deviceId, extensionId=extensionId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_extension_from_a_device" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_extension_from_a_device")

    async def update_provision_template_to_device(
        self,
        deviceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update provision template of a device

        HTTP PUT /phone/devices/{deviceId}/provision_templates

        Args:
            deviceId: The device ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/devices/{deviceId}/provision_templates".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_provision_template_to_device" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_provision_template_to_device")

    async def reboot_phone_device(
        self,
        deviceId: str
    ) -> ZoomResponse:
        """Reboot a desk phone

        HTTP POST /phone/devices/{deviceId}/reboot

        Args:
            deviceId: Unique identifier of the device.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/devices/{deviceId}/reboot".format(deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed reboot_phone_device" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute reboot_phone_device")

    async def list_smartphones(
        self,
        site_id: str | None = None,
        keyword: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List Smartphones

        HTTP GET /phone/smartphones

        Args:
            site_id: The site of the assignee.
            keyword: The device name, common area, serial number, or IP address to filter the results.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            page_size: The number of records returned within a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if site_id is not None:
            query_params['site_id'] = site_id
        if keyword is not None:
            query_params['keyword'] = keyword
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/smartphones"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_smartphones" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_smartphones")

    async def add_byoc_number(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add BYOC phone numbers

        HTTP POST /phone/byoc_numbers

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/byoc_numbers"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_byoc_number" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_byoc_number")

    async def list_account_phone_numbers(
        self,
        *,
        next_page_token: str | None = None,
        type_: str | None = None,
        extension_type: str | None = None,
        page_size: int | None = None,
        number_type: str | None = None,
        pending_numbers: bool | None = None,
        site_id: str | None = None
    ) -> ZoomResponse:
        """List phone numbers

        HTTP GET /phone/numbers

        Args:
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            type_: The query response by number assignment. The value can be one of the following:      `assigned`: The number has been ass
            extension_type: The type of assignee to whom the number is assigned. The parameter can be set only if `type` parameter is set as `assign
            page_size: The number of records returned within a single API call.
            number_type: The type of phone number. The value can be either `toll` or `tollfree`.
            pending_numbers: This field includes or excludes pending numbers in the response. The value can be either `true` or `false`.
            site_id: The unique identifier of the site. Use this query parameter if you have enabled multiple sites and would like to filter

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if type_ is not None:
            query_params['type'] = type_
        if extension_type is not None:
            query_params['extension_type'] = extension_type
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if number_type is not None:
            query_params['number_type'] = number_type
        if pending_numbers is not None:
            query_params['pending_numbers'] = str(pending_numbers).lower()
        if site_id is not None:
            query_params['site_id'] = site_id

        url = self.base_url + "/phone/numbers"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_account_phone_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_account_phone_numbers")

    async def delete_unassigned_phone_numbers(
        self,
        phone_numbers: list[object] | None = None
    ) -> ZoomResponse:
        """Delete unassigned phone numbers

        HTTP DELETE /phone/numbers

        Args:
            phone_numbers: Comma seperated list of unassigned phone numbers in E164 format or phone number IDs.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if phone_numbers is not None:
            query_params['phone_numbers'] = phone_numbers

        url = self.base_url + "/phone/numbers"

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_unassigned_phone_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_unassigned_phone_numbers")

    async def update_site_for_unassigned_phone_numbers(
        self,
        siteId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a site's unassigned phone numbers

        HTTP PATCH /phone/numbers/sites/{siteId}

        Args:
            siteId: Unique identifier of the site
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/numbers/sites/{siteId}".format(siteId=siteId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_site_for_unassigned_phone_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_site_for_unassigned_phone_numbers")

    async def get_phone_number_details(
        self,
        phoneNumberId: str
    ) -> ZoomResponse:
        """Get a phone number

        HTTP GET /phone/numbers/{phoneNumberId}

        Args:
            phoneNumberId: The unique identifier of the phone number retrieved from the List phone numbers API.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/numbers/{phoneNumberId}".format(phoneNumberId=phoneNumberId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_phone_number_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_phone_number_details")

    async def update_phone_number_details(
        self,
        phoneNumberId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a phone number

        HTTP PATCH /phone/numbers/{phoneNumberId}

        Args:
            phoneNumberId: The unique identifier of the phone number.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/numbers/{phoneNumberId}".format(phoneNumberId=phoneNumberId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_phone_number_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_phone_number_details")

    async def assign_phone_number(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign a phone number to a user

        HTTP POST /phone/users/{userId}/phone_numbers

        Args:
            userId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/phone_numbers".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assign_phone_number" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assign_phone_number")

    async def unassign_phone_number(
        self,
        userId: str,
        phoneNumberId: str
    ) -> ZoomResponse:
        """Unassign a phone number

        HTTP DELETE /phone/users/{userId}/phone_numbers/{phoneNumberId}

        Args:
            userId: This field provides either the user ID or email address of the user.
            phoneNumberId: This field provides either the phone number or phone number ID of the user.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/phone_numbers/{phoneNumberId}".format(userId=userId, phoneNumberId=phoneNumberId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed unassign_phone_number" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute unassign_phone_number")

    async def list_calling_plans(
        self
    ) -> ZoomResponse:
        """List calling plans

        HTTP GET /phone/calling_plans

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/calling_plans"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_calling_plans" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_calling_plans")

    async def list_phone_plans(
        self
    ) -> ZoomResponse:
        """List plan information

        HTTP GET /phone/plans

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/plans"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_phone_plans" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_phone_plans")

    async def list_phone_roles(
        self
    ) -> ZoomResponse:
        """List phone roles

        HTTP GET /phone/roles

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/roles"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_phone_roles" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_phone_roles")

    async def duplicate_phone_role(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Duplicate a phone role

        HTTP POST /phone/roles

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/roles"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed duplicate_phone_role" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute duplicate_phone_role")

    async def get_role_information_1(
        self,
        roleId: str
    ) -> ZoomResponse:
        """Get role information

        HTTP GET /phone/roles/{roleId}

        Args:
            roleId: The role ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/roles/{roleId}".format(roleId=roleId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_role_information_1" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_role_information_1")

    async def delete_phone_role(
        self,
        roleId: str
    ) -> ZoomResponse:
        """Delete a phone role

        HTTP DELETE /phone/roles/{roleId}

        Args:
            roleId: Unique identifier of the [role](https://support.zoom.us/hc/en-us/articles/360042099012-Using-Zoom-Phone-role-management)

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/roles/{roleId}".format(roleId=roleId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_phone_role" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_phone_role")

    async def update_phone_role(
        self,
        roleId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a phone role

        HTTP PATCH /phone/roles/{roleId}

        Args:
            roleId: Unique identifier of the [role](https://support.zoom.us/hc/en-us/articles/360042099012-Using-Zoom-Phone-role-management)
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/roles/{roleId}".format(roleId=roleId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_phone_role" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_phone_role")

    async def list_role_members(
        self,
        roleId: str,
        *,
        in_role: bool | None = None
    ) -> ZoomResponse:
        """List members in a role

        HTTP GET /phone/roles/{roleId}/members

        Args:
            roleId: Unique identifier of the [role](https://support.zoom.us/hc/en-us/articles/360042099012-Using-Zoom-Phone-role-management)
            in_role: Whether the user belongs to the role: default is `false`.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if in_role is not None:
            query_params['in_role'] = str(in_role).lower()

        url = self.base_url + "/phone/roles/{roleId}/members".format(roleId=roleId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_role_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_role_members")

    async def add_role_members_1(
        self,
        roleId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add members to roles

        HTTP POST /phone/roles/{roleId}/members

        Args:
            roleId: Unique identifier of the [role](https://support.zoom.us/hc/en-us/articles/360042099012-Using-Zoom-Phone-role-management)
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/roles/{roleId}/members".format(roleId=roleId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_role_members_1" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_role_members_1")

    async def del_role_members(
        self,
        roleId: str,
        user_ids: list[object] | None = None
    ) -> ZoomResponse:
        """Delete members in a role

        HTTP DELETE /phone/roles/{roleId}/members

        Args:
            roleId: Unique identifier of the [role](https://support.zoom.us/hc/en-us/articles/360042099012-Using-Zoom-Phone-role-management)
            user_ids: The user IDs or email addresses of the user

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if user_ids is not None:
            query_params['user_ids'] = user_ids

        url = self.base_url + "/phone/roles/{roleId}/members".format(roleId=roleId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed del_role_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute del_role_members")

    async def list_phone_role_targets(
        self,
        roleId: str,
        *,
        is_default: bool | None = None,
        user_id: str | None = None,
        selected: bool | None = None,
        target_type: str | None = None,
        site_id: str | None = None,
        keyword: str | None = None,
        page_size: str | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List phone role targets

        HTTP GET /phone/roles/{roleId}/targets

        Args:
            roleId: The unique identifier of the [role](https://support.zoom.us/hc/en-us/articles/360042099012-Using-Zoom-Phone-role-managem
            is_default: If`is_default`=`true`, it manages the role default targets. If `is_default`=`false`, it manages the role member targets.
            user_id: The role member ID. It's required if `is_default`=`false`.
            selected: `selected`=`true`filters the targets that are in the role.  `selected`=`false` filters the targets that are not in the r
            target_type: The target type.   Different types of roles manage different types of targets:    * super_admin: need not manage targets
            site_id: The unique identifier of the site.
            keyword: The keyword of the name or extension ID. It provides the ability to search by keyword.
            page_size: The number of records returned from a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if is_default is not None:
            query_params['is_default'] = str(is_default).lower()
        if user_id is not None:
            query_params['user_id'] = user_id
        if selected is not None:
            query_params['selected'] = str(selected).lower()
        if target_type is not None:
            query_params['target_type'] = target_type
        if site_id is not None:
            query_params['site_id'] = site_id
        if keyword is not None:
            query_params['keyword'] = keyword
        if page_size is not None:
            query_params['page_size'] = page_size
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/roles/{roleId}/targets".format(roleId=roleId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_phone_role_targets" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_phone_role_targets")

    async def add_phone_role_targets(
        self,
        roleId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add phone role targets

        HTTP POST /phone/roles/{roleId}/targets

        Args:
            roleId: The unique identifier of the [role](https://support.zoom.us/hc/en-us/articles/360042099012-Using-Zoom-Phone-role-managem
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/roles/{roleId}/targets".format(roleId=roleId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_phone_role_targets" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_phone_role_targets")

    async def delete_phone_role_targets(
        self,
        roleId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Delete phone role targets

        HTTP DELETE /phone/roles/{roleId}/targets

        Args:
            roleId: The unique identifier of the [role](https://support.zoom.us/hc/en-us/articles/360042099012-Using-Zoom-Phone-role-managem
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/roles/{roleId}/targets".format(roleId=roleId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_phone_role_targets" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_phone_role_targets")

    async def list_private_directory_members(
        self,
        next_page_token: str | None = None,
        page_size: int | None = None,
        keyword: str | None = None,
        site_id: str | None = None
    ) -> ZoomResponse:
        """List private directory members

        HTTP GET /phone/private_directory/members

        Args:
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            page_size: The number of records returned within a single API call.
            keyword: The partial string of the private directory's member number. It only supports suffix fuzzy matching for the extension nu
            site_id: The unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-multiple-sites) that

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if keyword is not None:
            query_params['keyword'] = keyword
        if site_id is not None:
            query_params['site_id'] = site_id

        url = self.base_url + "/phone/private_directory/members"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_private_directory_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_private_directory_members")

    async def add_members_to_a_private_directory(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add members to a private directory

        HTTP POST /phone/private_directory/members

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/private_directory/members"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_members_to_a_private_directory" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_members_to_a_private_directory")

    async def remove_a_member_from_a_private_directory(
        self,
        extensionId: str,
        site_id: str | None = None
    ) -> ZoomResponse:
        """Remove a member from a private directory

        HTTP DELETE /phone/private_directory/members/{extensionId}

        Args:
            extensionId: The member's extension ID.
            site_id: The unique identifier of the [site](https://support.zoom.us/hc/en-us/articles/360020809672-Managing-multiple-sites) that

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if site_id is not None:
            query_params['site_id'] = site_id

        url = self.base_url + "/phone/private_directory/members/{extensionId}".format(extensionId=extensionId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed remove_a_member_from_a_private_directory" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute remove_a_member_from_a_private_directory")

    async def update_a_private_directory_member(
        self,
        extensionId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a private directory member

        HTTP PATCH /phone/private_directory/members/{extensionId}

        Args:
            extensionId: The member's extension ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/private_directory/members/{extensionId}".format(extensionId=extensionId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_a_private_directory_member" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_a_private_directory_member")

    async def list_carrier_peering_phone_numbers(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        phone_number: str | None = None
    ) -> ZoomResponse:
        """List carrier peering phone numbers.

        HTTP GET /phone/carrier_peering/numbers

        Args:
            page_size: The total number of records returned from a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            phone_number: This field filters results by the given phone number.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if phone_number is not None:
            query_params['phone_number'] = phone_number

        url = self.base_url + "/phone/carrier_peering/numbers"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_carrier_peering_phone_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_carrier_peering_phone_numbers")

    async def list_peering_phone_numbers(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        phone_number: str | None = None,
        carrier_code: int | None = None
    ) -> ZoomResponse:
        """List peering phone numbers

        HTTP GET /phone/peering/numbers

        Args:
            page_size: The total number of records returned from a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            phone_number: The sender's or receiver's phone number that limits the list of SMS sessions.
            carrier_code: The carrier's code. The `clientId` that maps to a carrier peered with Zoom.  This parameter is required if you do **not*

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if phone_number is not None:
            query_params['phone_number'] = phone_number
        if carrier_code is not None:
            query_params['carrier_code'] = str(carrier_code)

        url = self.base_url + "/phone/peering/numbers"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_peering_phone_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_peering_phone_numbers")

    async def add_peering_phone_numbers(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add peering phone numbers

        HTTP POST /phone/peering/numbers

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/peering/numbers"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_peering_phone_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_peering_phone_numbers")

    async def delete_peering_phone_numbers(
        self,
        carrier_code: int | None = None,
        phone_numbers: list[object] | None = None
    ) -> ZoomResponse:
        """Remove peering phone numbers

        HTTP DELETE /phone/peering/numbers

        Args:
            carrier_code: The carrier's code. The `clientId` maps to a carrier peered with Zoom.  This parameter is required if you do **not** use
            phone_numbers: The information about the removed phone numbers. Maximum of 200.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if carrier_code is not None:
            query_params['carrier_code'] = str(carrier_code)
        if phone_numbers is not None:
            query_params['phone_numbers'] = phone_numbers

        url = self.base_url + "/phone/peering/numbers"

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_peering_phone_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_peering_phone_numbers")

    async def update_peering_phone_numbers(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update peering phone numbers

        HTTP PATCH /phone/peering/numbers

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/peering/numbers"

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_peering_phone_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_peering_phone_numbers")

    async def list_account_provision_template(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List provision templates

        HTTP GET /phone/provision_templates

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/provision_templates"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_account_provision_template" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_account_provision_template")

    async def add_provision_template(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a provision template

        HTTP POST /phone/provision_templates

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/provision_templates"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_provision_template" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_provision_template")

    async def get_provision_template(
        self,
        templateId: str
    ) -> ZoomResponse:
        """Get a provision template

        HTTP GET /phone/provision_templates/{templateId}

        Args:
            templateId: The template ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/provision_templates/{templateId}".format(templateId=templateId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_provision_template" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_provision_template")

    async def delete_provision_template(
        self,
        templateId: str
    ) -> ZoomResponse:
        """Delete a provision template

        HTTP DELETE /phone/provision_templates/{templateId}

        Args:
            templateId: The template ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/provision_templates/{templateId}".format(templateId=templateId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_provision_template" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_provision_template")

    async def update_provision_template(
        self,
        templateId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a provision template

        HTTP PATCH /phone/provision_templates/{templateId}

        Args:
            templateId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/provision_templates/{templateId}".format(templateId=templateId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_provision_template" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_provision_template")

    async def get_phone_recordings_by_call_id_or_call_log_id(
        self,
        id_: str
    ) -> ZoomResponse:
        """Get recording by call ID

        HTTP GET /phone/call_logs/{id}/recordings

        Args:
            id_: This field gets the unique ID of the call log. You can use `callLogId` and `callId` as path parameters. You can find the

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/call_logs/{id_}/recordings".format(id_=id_)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_phone_recordings_by_call_id_or_call_log_id" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_phone_recordings_by_call_id_or_call_log_id")

    async def phone_download_recording_file(
        self,
        fileId: str
    ) -> ZoomResponse:
        """Download a phone recording

        HTTP GET /phone/recording/download/{fileId}

        Args:
            fileId: The file ID of the phone recording.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/recording/download/{fileId}".format(fileId=fileId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed phone_download_recording_file" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute phone_download_recording_file")

    async def phone_download_recording_transcript(
        self,
        recordingId: str
    ) -> ZoomResponse:
        """Download a phone recording transcript

        HTTP GET /phone/recording_transcript/download/{recordingId}

        Args:
            recordingId: The phone recording ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/recording_transcript/download/{recordingId}".format(recordingId=recordingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed phone_download_recording_transcript" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute phone_download_recording_transcript")

    async def get_phone_recordings(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        owner_type: str | None = None,
        recording_type: str | None = None,
        site_id: str | None = None,
        query_date_type: str | None = None,
        group_id: str | None = None
    ) -> ZoomResponse:
        """Get call recordings

        HTTP GET /phone/recordings

        Args:
            page_size: The number of records returned within a single API call.   The default is **30** and the maximum is **300**.
            next_page_token: The current page number of the returned records.
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd T HH:mm:ssZ** format.   The date range defined in the `from` a
            to: This field is **required** only when the `from` parameter is specified.   The end time and date display in **yyyy-mm-dd*
            owner_type: The owner type.   The allowed values are `null`, `user`, `callQueue`, or `sharedOffice`(deprecated and to be replaced by
            recording_type: The recording type. The allowed values are `null`, `OnDemand`, or `Automatic`. The default value is `null`. If `null`, i
            site_id: The site ID.   The default value is `All sites`.
            query_date_type: The query date type, which can be `start_time` or `end_time`.   The default value is `start_time`.
            group_id: The group ID.   The default value is `All groups`.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if owner_type is not None:
            query_params['owner_type'] = owner_type
        if recording_type is not None:
            query_params['recording_type'] = recording_type
        if site_id is not None:
            query_params['site_id'] = site_id
        if query_date_type is not None:
            query_params['query_date_type'] = query_date_type
        if group_id is not None:
            query_params['group_id'] = group_id

        url = self.base_url + "/phone/recordings"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_phone_recordings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_phone_recordings")

    async def delete_call_recording(
        self,
        recordingId: str
    ) -> ZoomResponse:
        """Delete a call recording

        HTTP DELETE /phone/recordings/{recordingId}

        Args:
            recordingId: The unique identifier of the recording.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/recordings/{recordingId}".format(recordingId=recordingId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_call_recording" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_call_recording")

    async def update_auto_delete_field(
        self,
        recordingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update auto delete field

        HTTP PATCH /phone/recordings/{recordingId}

        Args:
            recordingId: The unique identifier of the recording.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/recordings/{recordingId}".format(recordingId=recordingId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_auto_delete_field" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_auto_delete_field")

    async def update_recording_status(
        self,
        recordingId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update Recording Status

        HTTP PUT /phone/recordings/{recordingId}/status

        Args:
            recordingId: The recording ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/recordings/{recordingId}/status".format(recordingId=recordingId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_recording_status" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_recording_status")

    async def phone_user_recordings(
        self,
        userId: str,
        page_size: int | None = None,
        next_page_token: str | None = None,
        from_: str | None = None,
        to: str | None = None
    ) -> ZoomResponse:
        """Get user's recordings

        HTTP GET /phone/users/{userId}/recordings

        Args:
            userId: The user ID or email address of the user. For user-level apps, pass `me` as the value for userId.
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through large result sets. A next page token returns whenever the set of available results
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format. The date range defined by the `from` a
            to: **Required** only when the `from` parameter is specified. End time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to

        url = self.base_url + "/phone/users/{userId}/recordings".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed phone_user_recordings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute phone_user_recordings")

    async def get_call_charges_usage_report(
        self,
        *,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        billing_account_id: str | None = None,
        show_charges_only: bool | None = None
    ) -> ZoomResponse:
        """Get call charges usage report

        HTTP GET /phone/reports/call_charges

        Args:
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format. The date range defined by the `from` a
            to: **Required** only when the `from` parameter is specified. The end time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:m
            page_size: The number of records to be returned within a single API call. The default is **30** and the maximum is **300**.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            billing_account_id: The billing account ID.
            show_charges_only: This field shows calls with charges only. The default value is `false`.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if billing_account_id is not None:
            query_params['billing_account_id'] = billing_account_id
        if show_charges_only is not None:
            query_params['show_charges_only'] = str(show_charges_only).lower()

        url = self.base_url + "/phone/reports/call_charges"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_call_charges_usage_report" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_call_charges_usage_report")

    async def getfaxchargesusagereport(
        self,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        fax_id: str | None = None
    ) -> ZoomResponse:
        """Get fax charges usage report

        HTTP GET /phone/reports/fax_charges

        Args:
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format. The date range defined by the `from` a
            to: **Required** only when the `from` parameter is specified. The end time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:m
            page_size: The number of records to be returned within a single API call. The default is 30 and the maximum is 300.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            fax_id: The fax ID is used to filter the charge of a specific fax within the period.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if fax_id is not None:
            query_params['fax_id'] = fax_id

        url = self.base_url + "/phone/reports/fax_charges"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getfaxchargesusagereport" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getfaxchargesusagereport")

    async def get_ps_operation_logs(
        self,
        from_: str | None = None,
        to: str | None = None,
        category_type: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get operation logs report

        HTTP GET /phone/reports/operationlogs

        Args:
            from_: The start time and date in **yyyy-mm-dd**format. The date range defined by the `from` and `to` parameters should be a mo
            to: **Required** only when the `from` parameter is specified. The end time and date is in **yyyy-mm-dd** format; the same fo
            category_type: This field filters the response by the category of the action performed. By default, the value of this field is &quot;al
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through large set of results. A next page token returns whenever the set of available resu

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if category_type is not None:
            query_params['category_type'] = category_type
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/reports/operationlogs"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_ps_operation_logs" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_ps_operation_logs")

    async def get_sms_charges_usage_report(
        self,
        *,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        show_charges_only: bool | None = None
    ) -> ZoomResponse:
        """Get SMS/MMS charges usage report

        HTTP GET /phone/reports/sms_charges

        Args:
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format. The date range defined by the `from` a
            to: This field is **required** only when you specify the `from` parameter. End time and date is in a **yyyy-mm-dd** or **yyy
            page_size: The number of records returned within a single API call. The default is **30**, and the maximum is **300**.
            next_page_token: The current page number of returned records.
            show_charges_only: This field shows sms/mms with charges only. Defaults to false.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if show_charges_only is not None:
            query_params['show_charges_only'] = str(show_charges_only).lower()

        url = self.base_url + "/phone/reports/sms_charges"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_sms_charges_usage_report" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_sms_charges_usage_report")

    async def list_routing_rule(
        self,
        site_id: str | None = None
    ) -> ZoomResponse:
        """List directory backup routing rules

        HTTP GET /phone/routing_rules

        Args:
            site_id: The unique identifier of the site.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if site_id is not None:
            query_params['site_id'] = site_id

        url = self.base_url + "/phone/routing_rules"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_routing_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_routing_rule")

    async def add_routing_rule(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add directory backup routing rule

        HTTP POST /phone/routing_rules

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/routing_rules"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_routing_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_routing_rule")

    async def get_routing_rule(
        self,
        routingRuleId: str
    ) -> ZoomResponse:
        """Get directory backup routing rule

        HTTP GET /phone/routing_rules/{routingRuleId}

        Args:
            routingRuleId: The unique identifier of the routing rule.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/routing_rules/{routingRuleId}".format(routingRuleId=routingRuleId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_routing_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_routing_rule")

    async def delete_routing_rule(
        self,
        routingRuleId: str
    ) -> ZoomResponse:
        """Delete directory backup routing rule

        HTTP DELETE /phone/routing_rules/{routingRuleId}

        Args:
            routingRuleId: The unique identifier of the routing rule.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/routing_rules/{routingRuleId}".format(routingRuleId=routingRuleId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_routing_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_routing_rule")

    async def update_routing_rule(
        self,
        routingRuleId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update directory backup routing rule

        HTTP PATCH /phone/routing_rules/{routingRuleId}

        Args:
            routingRuleId: The unique identifier of the routing rule.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/routing_rules/{routingRuleId}".format(routingRuleId=routingRuleId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_routing_rule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_routing_rule")

    async def post_sms_message(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Post SMS message

        HTTP POST /phone/sms/messages

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sms/messages"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed post_sms_message" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute post_sms_message")

    async def account_sms_session(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        session_type: str | None = None,
        phone_number: str | None = None,
        filter_type: str | None = None
    ) -> ZoomResponse:
        """Get account's SMS sessions

        HTTP GET /phone/sms/sessions

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: The current page number of returned records.
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format.   The date range defined by the `from`
            to: This field is required only when the `from` parameter is specified.   End time and date in **yyyy-mm-dd** or **yyyy-MM-d
            session_type: This field filters the specific session list by a session type.  The value for this field can be one of the following:
            phone_number: The sender's or receiver's phone number that limits the list of SMS sessions.
            filter_type: This field filters by `sent_message_time`, `received_message_time`, `last_message_time`, or `sent_received_message_time`

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if session_type is not None:
            query_params['session_type'] = session_type
        if phone_number is not None:
            query_params['phone_number'] = phone_number
        if filter_type is not None:
            query_params['filter_type'] = filter_type

        url = self.base_url + "/phone/sms/sessions"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed account_sms_session" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute account_sms_session")

    async def sms_session_details(
        self,
        sessionId: str,
        page_size: int | None = None,
        next_page_token: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        sort: int | None = None
    ) -> ZoomResponse:
        """Get SMS session details

        HTTP GET /phone/sms/sessions/{sessionId}

        Args:
            sessionId: The SMS session ID.
            page_size: The number of records returned within a single API call.
            next_page_token: The current page number of returned records.
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format. The date range defined by the `from` a
            to: **Required** only when the `from` parameter is specified. End time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss
            sort: The order of the SMS to return based on creation time. `1`: ascending `2`: descending

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if sort is not None:
            query_params['sort'] = str(sort)

        url = self.base_url + "/phone/sms/sessions/{sessionId}".format(sessionId=sessionId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed sms_session_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute sms_session_details")

    async def sms_by_message_id(
        self,
        sessionId: str,
        messageId: str
    ) -> ZoomResponse:
        """Get SMS by message ID

        HTTP GET /phone/sms/sessions/{sessionId}/messages/{messageId}

        Args:
            sessionId: The SMS session ID.
            messageId: The SMS message ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sms/sessions/{sessionId}/messages/{messageId}".format(sessionId=sessionId, messageId=messageId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed sms_by_message_id" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute sms_by_message_id")

    async def sms_session_sync(
        self,
        sessionId: str,
        sync_type: str | None = None,
        count: int | None = None,
        sync_token: str | None = None
    ) -> ZoomResponse:
        """Sync SMS by session ID

        HTTP GET /phone/sms/sessions/{sessionId}/sync

        Args:
            sessionId: The SMS session ID.
            sync_type: The options for synchronizing SMS message:     FSync - Full sync     ISync - Increase sync     BSync - Backward sync
            count: The number of records returned within a single API call.
            sync_token: The time range for returned records. It's used for locating where the next retrieval will begin.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if sync_type is not None:
            query_params['sync_type'] = sync_type
        if count is not None:
            query_params['count'] = str(count)
        if sync_token is not None:
            query_params['sync_token'] = sync_token

        url = self.base_url + "/phone/sms/sessions/{sessionId}/sync".format(sessionId=sessionId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed sms_session_sync" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute sms_session_sync")

    async def user_sms_session(
        self,
        userId: str,
        page_size: int | None = None,
        next_page_token: str | None = None,
        session_type: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        phone_number: str | None = None,
        filter_type: str | None = None
    ) -> ZoomResponse:
        """Get user's SMS sessions

        HTTP GET /phone/users/{userId}/sms/sessions

        Args:
            userId: The user ID, user email, or &ldquo;me&rdquo; when using OAuth token.
            page_size: The number of records returned within a single API call.
            next_page_token: The current page number of returned records.
            session_type: This field filters the specific session list by a session type.  The value for this field can be one of the following:
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format.   The date range defined by the `from`
            to: This field is required only when the `from` parameter is specified.   The end time and date in **yyyy-mm-dd** or **yyyy-
            phone_number: The sender's or receiver's phone number that limits the list of SMS sessions.
            filter_type: This field filters by `sent_message_time`, `received_message_time`, `last_message_time`, or `sent_received_message_time`

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if session_type is not None:
            query_params['session_type'] = session_type
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if phone_number is not None:
            query_params['phone_number'] = phone_number
        if filter_type is not None:
            query_params['filter_type'] = filter_type

        url = self.base_url + "/phone/users/{userId}/sms/sessions".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_sms_session" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_sms_session")

    async def get_sms_sessions(
        self,
        userId: str,
        sync_type: str | None = None,
        sync_token: str | None = None,
        count: int | None = None,
        session_type: str | None = None
    ) -> ZoomResponse:
        """List user's SMS sessions in descending order

        HTTP GET /phone/users/{userId}/sms/sessions/sync

        Args:
            userId: The user ID, user email, or &ldquo;me&rdquo; when using OAuth token.
            sync_type: FSync: Full sync BSync: Backward sync ISync: Forward sync
            sync_token: The sync token. Use if requesting a backward (`BSync`) or forward (`ISync`) sync.
            count: The record count of each query
            session_type: This field filters the specific session list by a session type. The value for this field can be one of the following:

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if sync_type is not None:
            query_params['sync_type'] = sync_type
        if sync_token is not None:
            query_params['sync_token'] = sync_token
        if count is not None:
            query_params['count'] = str(count)
        if session_type is not None:
            query_params['session_type'] = session_type

        url = self.base_url + "/phone/users/{userId}/sms/sessions/sync".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_sms_sessions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_sms_sessions")

    async def list_account_sms_campaigns(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List SMS campaigns

        HTTP GET /phone/sms_campaigns

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/sms_campaigns"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_account_sms_campaigns" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_account_sms_campaigns")

    async def get_sms_campaign(
        self,
        smsCampaignId: str
    ) -> ZoomResponse:
        """Get an SMS campaign

        HTTP GET /phone/sms_campaigns/{smsCampaignId}

        Args:
            smsCampaignId: Path parameter

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sms_campaigns/{smsCampaignId}".format(smsCampaignId=smsCampaignId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_sms_campaign" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_sms_campaign")

    async def assign_campaign_phone_numbers(
        self,
        smsCampaignId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign a phone number to SMS campaign

        HTTP POST /phone/sms_campaigns/{smsCampaignId}/phone_numbers

        Args:
            smsCampaignId: The unique identifier of the campaign to which the phone number will be assigned.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sms_campaigns/{smsCampaignId}/phone_numbers".format(smsCampaignId=smsCampaignId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assign_campaign_phone_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assign_campaign_phone_numbers")

    async def get_number_campaign_opt_status(
        self,
        smsCampaignId: str,
        consumer_phone_number: str | None = None,
        zoom_phone_user_numbers: list[object] | None = None
    ) -> ZoomResponse:
        """List opt statuses of phone numbers assigned to SMS campaign

        HTTP GET /phone/sms_campaigns/{smsCampaignId}/phone_numbers/opt_status

        Args:
            smsCampaignId: The SMS campaign ID.
            consumer_phone_number: The end user's phone number that sends the Opt-in or Opt-out keyword to the Zoom Phone number.
            zoom_phone_user_numbers: The Zoom users' phone numbers that receive the Opt-in or Opt-out keyword from the end user.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if consumer_phone_number is not None:
            query_params['consumer_phone_number'] = consumer_phone_number
        if zoom_phone_user_numbers is not None:
            query_params['zoom_phone_user_numbers'] = zoom_phone_user_numbers

        url = self.base_url + "/phone/sms_campaigns/{smsCampaignId}/phone_numbers/opt_status".format(smsCampaignId=smsCampaignId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_number_campaign_opt_status" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_number_campaign_opt_status")

    async def update_number_campaign_opt_status(
        self,
        smsCampaignId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update opt statuses of phone numbers assigned to SMS campaign

        HTTP PATCH /phone/sms_campaigns/{smsCampaignId}/phone_numbers/opt_status

        Args:
            smsCampaignId: The SMS campaign ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sms_campaigns/{smsCampaignId}/phone_numbers/opt_status".format(smsCampaignId=smsCampaignId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_number_campaign_opt_status" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_number_campaign_opt_status")

    async def unassign_campaign_phone_number(
        self,
        smsCampaignId: str,
        phoneNumberId: str
    ) -> ZoomResponse:
        """Unassign a phone number

        HTTP DELETE /phone/sms_campaigns/{smsCampaignId}/phone_numbers/{phoneNumberId}

        Args:
            smsCampaignId: Path parameter
            phoneNumberId: Provide either phone number (in E164 format) or phoneNumberId of the campaign.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sms_campaigns/{smsCampaignId}/phone_numbers/{phoneNumberId}".format(smsCampaignId=smsCampaignId, phoneNumberId=phoneNumberId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed unassign_campaign_phone_number" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute unassign_campaign_phone_number")

    async def get_user_number_campaign_opt_status(
        self,
        userId: str,
        consumer_phone_numbers: list[object] | None = None,
        zoom_phone_user_numbers: list[object] | None = None
    ) -> ZoomResponse:
        """List user's opt statuses of phone numbers

        HTTP GET /phone/user/{userId}/sms_campaigns/phone_numbers/opt_status

        Args:
            userId: The user ID.
            consumer_phone_numbers: The end user's phone number that sends the Opt-in or Opt-out keyword to the Zoom Phone number.
            zoom_phone_user_numbers: The Zoom users' phone numbers that receive the Opt-in or Opt-out keyword from the end user.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if consumer_phone_numbers is not None:
            query_params['consumer_phone_numbers'] = consumer_phone_numbers
        if zoom_phone_user_numbers is not None:
            query_params['zoom_phone_user_numbers'] = zoom_phone_user_numbers

        url = self.base_url + "/phone/user/{userId}/sms_campaigns/phone_numbers/opt_status".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_user_number_campaign_opt_status" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_user_number_campaign_opt_status")

    async def list_setting_templates(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        site_id: str | None = None
    ) -> ZoomResponse:
        """List setting templates

        HTTP GET /phone/setting_templates

        Args:
            page_size: Number of records returns within a single API call.
            next_page_token: The next page token is used to paginate through large result sets. A next page token will be returned whenever the set o
            site_id: Unique identifier of the site. This field is required only if multiple sites have been enabled.  of the site. Required o

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if site_id is not None:
            query_params['site_id'] = site_id

        url = self.base_url + "/phone/setting_templates"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_setting_templates" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_setting_templates")

    async def add_setting_template(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a setting template

        HTTP POST /phone/setting_templates

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/setting_templates"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_setting_template" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_setting_template")

    async def get_setting_template(
        self,
        templateId: str,
        custom_query_fields: str | None = None
    ) -> ZoomResponse:
        """Get setting template details

        HTTP GET /phone/setting_templates/{templateId}

        Args:
            templateId: The unique identifier of the template.
            custom_query_fields: This field provides the name of the field to use to filter the response. For example, if you provide &quot;description&q

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if custom_query_fields is not None:
            query_params['custom_query_fields'] = custom_query_fields

        url = self.base_url + "/phone/setting_templates/{templateId}".format(templateId=templateId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_setting_template" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_setting_template")

    async def update_setting_template(
        self,
        templateId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a setting template

        HTTP PATCH /phone/setting_templates/{templateId}

        Args:
            templateId: The Template ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/setting_templates/{templateId}".format(templateId=templateId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_setting_template" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_setting_template")

    async def get_account_policy_details(
        self,
        policyType: str
    ) -> ZoomResponse:
        """Get account policy details

        HTTP GET /phone/policies/{policyType}

        Args:
            policyType: This field specifies the type of policy to retrieve or modify. See the documentation for detailed behavior of each polic

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/policies/{policyType}".format(policyType=policyType)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_account_policy_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_account_policy_details")

    async def update_account_policy(
        self,
        policyType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update account policy

        HTTP PATCH /phone/policies/{policyType}

        Args:
            policyType: This field epecifies the type of policy to retrieve or modify. See the documentation for detailed behavior of each polic
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/policies/{policyType}".format(policyType=policyType)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_account_policy" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_account_policy")

    async def list_ported_numbers(
        self,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List ported numbers

        HTTP GET /phone/ported_numbers/orders

        Args:
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            page_size: The number of records returned within a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/ported_numbers/orders"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_ported_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_ported_numbers")

    async def get_ported_numbers_details(
        self,
        orderId: str
    ) -> ZoomResponse:
        """Get ported number details

        HTTP GET /phone/ported_numbers/orders/{orderId}

        Args:
            orderId: Order ID of the ported numbers. This can be retrieved from the List Ported Numbers API.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/ported_numbers/orders/{orderId}".format(orderId=orderId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_ported_numbers_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_ported_numbers_details")

    async def phone_setting(
        self
    ) -> ZoomResponse:
        """Get phone account settings

        HTTP GET /phone/settings

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/settings"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed phone_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute phone_setting")

    async def update_phone_settings(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update phone account settings

        HTTP PATCH /phone/settings

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/settings"

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_phone_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_phone_settings")

    async def list_sip_groups(
        self,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List SIP groups

        HTTP GET /phone/sip_groups

        Args:
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            page_size: The number of records returned within a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/sip_groups"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_sip_groups" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_sip_groups")

    async def list_byocsip_trunk(
        self,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List BYOC SIP trunks

        HTTP GET /phone/sip_trunk/trunks

        Args:
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            page_size: The number of records returned within a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/phone/sip_trunk/trunks"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_byocsip_trunk" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_byocsip_trunk")

    async def list_shared_line_appearances(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List shared line appearances

        HTTP GET /phone/shared_line_appearances

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/shared_line_appearances"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_shared_line_appearances" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_shared_line_appearances")

    async def list_shared_line_groups(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List shared line groups

        HTTP GET /phone/shared_line_groups

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/shared_line_groups"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_shared_line_groups" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_shared_line_groups")

    async def create_a_shared_line_group(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a shared line group

        HTTP POST /phone/shared_line_groups

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/shared_line_groups"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_a_shared_line_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_a_shared_line_group")

    async def get_a_shared_line_group(
        self,
        sharedLineGroupId: str
    ) -> ZoomResponse:
        """Get a shared line group

        HTTP GET /phone/shared_line_groups/{sharedLineGroupId}

        Args:
            sharedLineGroupId: The unique identifier of the shared line group.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/shared_line_groups/{sharedLineGroupId}".format(sharedLineGroupId=sharedLineGroupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_a_shared_line_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_a_shared_line_group")

    async def get_shared_line_group_policy(
        self,
        sharedLineGroupId: str
    ) -> ZoomResponse:
        """Get a shared line group policy

        HTTP GET /phone/shared_line_groups/{sharedLineGroupId}/policies

        Args:
            sharedLineGroupId: The unique identifier of the shared line group.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/shared_line_groups/{sharedLineGroupId}/policies".format(sharedLineGroupId=sharedLineGroupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_shared_line_group_policy" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_shared_line_group_policy")

    async def update_shared_line_group_policy(
        self,
        sharedLineGroupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a shared line group policy

        HTTP PATCH /phone/shared_line_groups/{sharedLineGroupId}/policies

        Args:
            sharedLineGroupId: The unique identifier of the shared line group.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/shared_line_groups/{sharedLineGroupId}/policies".format(sharedLineGroupId=sharedLineGroupId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_shared_line_group_policy" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_shared_line_group_policy")

    async def delete_a_shared_line_group(
        self,
        slgId: str
    ) -> ZoomResponse:
        """Delete a shared line group

        HTTP DELETE /phone/shared_line_groups/{slgId}

        Args:
            slgId: The shared line group ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/shared_line_groups/{slgId}".format(slgId=slgId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_a_shared_line_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_a_shared_line_group")

    async def update_a_shared_line_group(
        self,
        slgId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a shared line group

        HTTP PATCH /phone/shared_line_groups/{slgId}

        Args:
            slgId: The shared line group ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/shared_line_groups/{slgId}".format(slgId=slgId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_a_shared_line_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_a_shared_line_group")

    async def add_members_to_shared_line_group(
        self,
        slgId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add members to a shared line group

        HTTP POST /phone/shared_line_groups/{slgId}/members

        Args:
            slgId: The shared line group ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/shared_line_groups/{slgId}/members".format(slgId=slgId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_members_to_shared_line_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_members_to_shared_line_group")

    async def delete_members_of_slg(
        self,
        slgId: str
    ) -> ZoomResponse:
        """Unassign members from a shared line group

        HTTP DELETE /phone/shared_line_groups/{slgId}/members

        Args:
            slgId: The shared line group ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/shared_line_groups/{slgId}/members".format(slgId=slgId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_members_of_slg" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_members_of_slg")

    async def delete_a_member_slg(
        self,
        slgId: str,
        memberId: str
    ) -> ZoomResponse:
        """Unassign a member from a shared line group

        HTTP DELETE /phone/shared_line_groups/{slgId}/members/{memberId}

        Args:
            slgId: The unique identifier of the shared line group from which you would like to remove a member.
            memberId: The unique identifier of the member who is to be removed.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/shared_line_groups/{slgId}/members/{memberId}".format(slgId=slgId, memberId=memberId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_a_member_slg" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_a_member_slg")

    async def assign_phone_numbers_slg(
        self,
        slgId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign phone numbers

        HTTP POST /phone/shared_line_groups/{slgId}/phone_numbers

        Args:
            slgId: The shared line group ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/shared_line_groups/{slgId}/phone_numbers".format(slgId=slgId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assign_phone_numbers_slg" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assign_phone_numbers_slg")

    async def delete_phone_numbers_slg(
        self,
        slgId: str
    ) -> ZoomResponse:
        """Unassign all phone numbers

        HTTP DELETE /phone/shared_line_groups/{slgId}/phone_numbers

        Args:
            slgId: The shared line group ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/shared_line_groups/{slgId}/phone_numbers".format(slgId=slgId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_phone_numbers_slg" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_phone_numbers_slg")

    async def delete_a_phone_number_slg(
        self,
        slgId: str,
        phoneNumberId: str
    ) -> ZoomResponse:
        """Unassign a phone number

        HTTP DELETE /phone/shared_line_groups/{slgId}/phone_numbers/{phoneNumberId}

        Args:
            slgId: Path parameter
            phoneNumberId: The unique identifier of the phone number which is to be unassigned. This can be retrieved from Get a Shared Line Group

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/shared_line_groups/{slgId}/phone_numbers/{phoneNumberId}".format(slgId=slgId, phoneNumberId=phoneNumberId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_a_phone_number_slg" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_a_phone_number_slg")

    async def add_slg_policy_sub_setting(
        self,
        slgId: str,
        policyType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a policy setting to a shared line group

        HTTP POST /phone/shared_line_groups/{slgId}/policies/{policyType}

        Args:
            slgId: Path parameter
            policyType: This setting corresponds to tbe policy item you wish to add. Allowed values: `voice_mail`.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/shared_line_groups/{slgId}/policies/{policyType}".format(slgId=slgId, policyType=policyType)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_slg_policy_sub_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_slg_policy_sub_setting")

    async def remove_slg_policy_sub_setting(
        self,
        slgId: str,
        policyType: str,
        shared_ids: list[object] | None = None
    ) -> ZoomResponse:
        """Delete an SLG policy setting

        HTTP DELETE /phone/shared_line_groups/{slgId}/policies/{policyType}

        Args:
            slgId: The shared line group ID.
            policyType: This setting corresponds to tbe policy item you wish to remove. Allowed values: `voice_mail`.
            shared_ids: The comma separated list of shared IDs to remove. The number is limited to the minimum value of 10 or the number of allo

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if shared_ids is not None:
            query_params['shared_ids'] = shared_ids

        url = self.base_url + "/phone/shared_line_groups/{slgId}/policies/{policyType}".format(slgId=slgId, policyType=policyType)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed remove_slg_policy_sub_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute remove_slg_policy_sub_setting")

    async def update_slg_policy_sub_setting(
        self,
        slgId: str,
        policyType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update an SLG policy setting

        HTTP PATCH /phone/shared_line_groups/{slgId}/policies/{policyType}

        Args:
            slgId: Path parameter
            policyType: This setting corresponds to tbe policy item you wish to update. Allowed values: `voice_mail`.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/shared_line_groups/{slgId}/policies/{policyType}".format(slgId=slgId, policyType=policyType)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_slg_policy_sub_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_slg_policy_sub_setting")

    async def list_phone_sites(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List phone sites

        HTTP GET /phone/sites

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/sites"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_phone_sites" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_phone_sites")

    async def create_phone_site(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a phone site

        HTTP POST /phone/sites

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sites"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_phone_site" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_phone_site")

    async def get_a_site(
        self,
        siteId: str
    ) -> ZoomResponse:
        """Get phone site details

        HTTP GET /phone/sites/{siteId}

        Args:
            siteId: The unique identifier of the site.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sites/{siteId}".format(siteId=siteId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_a_site" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_a_site")

    async def delete_phone_site(
        self,
        siteId: str,
        transfer_site_id: str | None = None
    ) -> ZoomResponse:
        """Delete a phone site

        HTTP DELETE /phone/sites/{siteId}

        Args:
            siteId: The unique identifier of the site.
            transfer_site_id: The site ID of another site where the assets of the current site (users, numbers and phones) can be transferred.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if transfer_site_id is not None:
            query_params['transfer_site_id'] = transfer_site_id

        url = self.base_url + "/phone/sites/{siteId}".format(siteId=siteId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_phone_site" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_phone_site")

    async def update_site_details(
        self,
        siteId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update phone site details

        HTTP PATCH /phone/sites/{siteId}

        Args:
            siteId: The unique identifier of the site.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sites/{siteId}".format(siteId=siteId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_site_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_site_details")

    async def list_site_customize_outbound_caller_numbers(
        self,
        siteId: str,
        *,
        selected: bool | None = None,
        site_id: str | None = None,
        extension_type: str | None = None,
        keyword: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List customized outbound caller ID phone numbers

        HTTP GET /phone/sites/{siteId}/outbound_caller_id/customized_numbers

        Args:
            siteId: The site ID.
            selected: Status of the phone numbers.    `true`- Numbers already added to the custom list.     `false`- Numbers not yet added to
            site_id: For filtering phone numbers that belong to the site.
            extension_type: The type of the extension to which the phone number belongs.
            keyword: A search keyword for phone or extension numbers.
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if selected is not None:
            query_params['selected'] = str(selected).lower()
        if site_id is not None:
            query_params['site_id'] = site_id
        if extension_type is not None:
            query_params['extension_type'] = extension_type
        if keyword is not None:
            query_params['keyword'] = keyword
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/sites/{siteId}/outbound_caller_id/customized_numbers".format(siteId=siteId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_site_customize_outbound_caller_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_site_customize_outbound_caller_numbers")

    async def add_site_outbound_caller_numbers(
        self,
        siteId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add customized outbound caller ID phone numbers

        HTTP POST /phone/sites/{siteId}/outbound_caller_id/customized_numbers

        Args:
            siteId: The site ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sites/{siteId}/outbound_caller_id/customized_numbers".format(siteId=siteId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_site_outbound_caller_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_site_outbound_caller_numbers")

    async def delete_site_outbound_caller_numbers(
        self,
        siteId: str,
        customize_ids: list[object] | None = None
    ) -> ZoomResponse:
        """Remove customized outbound caller ID phone numbers

        HTTP DELETE /phone/sites/{siteId}/outbound_caller_id/customized_numbers

        Args:
            siteId: The site ID.
            customize_ids: The customization IDs.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if customize_ids is not None:
            query_params['customize_ids'] = customize_ids

        url = self.base_url + "/phone/sites/{siteId}/outbound_caller_id/customized_numbers".format(siteId=siteId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_site_outbound_caller_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_site_outbound_caller_numbers")

    async def get_site_setting_for_type(
        self,
        siteId: str,
        settingType: str
    ) -> ZoomResponse:
        """Get a phone site setting

        HTTP GET /phone/sites/{siteId}/settings/{settingType}

        Args:
            siteId: The site ID.
            settingType: The site setting type:  * `local_based_routing`  * `business_hours`  * `closed_hours`  * `holiday_hours`  * `security`

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sites/{siteId}/settings/{settingType}".format(siteId=siteId, settingType=settingType)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_site_setting_for_type" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_site_setting_for_type")

    async def add_site_setting(
        self,
        siteId: str,
        settingType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a site setting

        HTTP POST /phone/sites/{siteId}/settings/{settingType}

        Args:
            siteId: The site ID.
            settingType: The site setting type:  * `holiday_hours`  * `security`.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sites/{siteId}/settings/{settingType}".format(siteId=siteId, settingType=settingType)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_site_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_site_setting")

    async def delete_site_setting(
        self,
        siteId: str,
        settingType: str,
        device_type: str | None = None,
        holiday_id: str | None = None
    ) -> ZoomResponse:
        """Delete a site setting

        HTTP DELETE /phone/sites/{siteId}/settings/{settingType}

        Args:
            siteId: The site ID.
            settingType: The site setting type:  * `holiday_hours`  * `security`.
            device_type: The device type. Enable SRTP AES-256 encryption on the site for the specified device type. Used for `security` setting t
            holiday_id: The holiday hour setting ID.  Used for `holiday_hours` setting type.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if device_type is not None:
            query_params['device_type'] = device_type
        if holiday_id is not None:
            query_params['holiday_id'] = holiday_id

        url = self.base_url + "/phone/sites/{siteId}/settings/{settingType}".format(siteId=siteId, settingType=settingType)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_site_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_site_setting")

    async def update_site_setting(
        self,
        siteId: str,
        settingType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update the site setting

        HTTP PATCH /phone/sites/{siteId}/settings/{settingType}

        Args:
            siteId: The site ID.
            settingType: The site setting type:  * `local_based_routing`  * `business_hours`  * `closed_hours`  * `holiday_hours` * `outbound_cal
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/sites/{siteId}/settings/{settingType}".format(siteId=siteId, settingType=settingType)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_site_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_site_setting")

    async def list_phone_users(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        site_id: str | None = None,
        calling_type: int | None = None,
        status: str | None = None,
        department: str | None = None,
        cost_center: str | None = None,
        keyword: str | None = None
    ) -> ZoomResponse:
        """List phone users

        HTTP GET /phone/users

        Args:
            page_size: The number of records returned from a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            site_id: The unique identifier of the site. Get it from the [List Phone Sites](https://marketplace.zoom.us/docs/api-reference/pho
            calling_type: The [type](https://marketplace.zoom.us/docs/api-reference/other-references/plans#zoom-phone-calling-plans) of calling pl
            status: The status of the Zoom Phone user.    `pending`: The users have been assigned the Zoom Workplace license, but not been a
            department: The department where the user belongs.
            cost_center: The cost center where the user belongs.
            keyword: The partial string of user's name, extension number, or phone number.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if site_id is not None:
            query_params['site_id'] = site_id
        if calling_type is not None:
            query_params['calling_type'] = str(calling_type)
        if status is not None:
            query_params['status'] = status
        if department is not None:
            query_params['department'] = department
        if cost_center is not None:
            query_params['cost_center'] = cost_center
        if keyword is not None:
            query_params['keyword'] = keyword

        url = self.base_url + "/phone/users"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_phone_users" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_phone_users")

    async def batch_add_users(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Batch add users

        HTTP POST /phone/users/batch

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/batch"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed batch_add_users" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute batch_add_users")

    async def update_users_properties_in_batch(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update multiple users' properties in batch

        HTTP PUT /phone/users/batch

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/batch"

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_users_properties_in_batch" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_users_properties_in_batch")

    async def phone_user(
        self,
        userId: str
    ) -> ZoomResponse:
        """Get a user's profile

        HTTP GET /phone/users/{userId}

        Args:
            userId: The user ID or email address of the user. For user-level apps, pass `me` as the value for userId.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed phone_user" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute phone_user")

    async def update_user_profile(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a user's profile

        HTTP PATCH /phone/users/{userId}

        Args:
            userId: The user ID or email address of the user. For user-level apps, pass `me` as the value for userId.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}".format(userId=userId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_user_profile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_user_profile")

    async def assign_calling_plan(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign calling plan to a user

        HTTP POST /phone/users/{userId}/calling_plans

        Args:
            userId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/calling_plans".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assign_calling_plan" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assign_calling_plan")

    async def update_calling_plan(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update user's calling plan

        HTTP PUT /phone/users/{userId}/calling_plans

        Args:
            userId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/calling_plans".format(userId=userId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_calling_plan" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_calling_plan")

    async def unassign_calling_plan(
        self,
        userId: str,
        planType: str,
        billing_account_id: str | None = None
    ) -> ZoomResponse:
        """Unassign user's calling plan

        HTTP DELETE /phone/users/{userId}/calling_plans/{planType}

        Args:
            userId: The ID of the user.
            planType: The type of plan. Refer to the [Plan Number section](https://marketplace.zoom.us/docs/api-reference/other-references/pla
            billing_account_id: The billing account ID. If the user is located in India, the parameter is required.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if billing_account_id is not None:
            query_params['billing_account_id'] = billing_account_id

        url = self.base_url + "/phone/users/{userId}/calling_plans/{planType}".format(userId=userId, planType=planType)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed unassign_calling_plan" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute unassign_calling_plan")

    async def list_user_customize_outbound_caller_numbers(
        self,
        userId: str,
        *,
        selected: bool | None = None,
        site_id: str | None = None,
        extension_type: str | None = None,
        keyword: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List users' phone numbers for a customized outbound caller ID

        HTTP GET /phone/users/{userId}/outbound_caller_id/customized_numbers

        Args:
            userId: The unique identifier of the user.
            selected: The status of the phone numbers.    `true`- Numbers already added to the custom list.     `false`- Numbers not yet added
            site_id: This field filters phone numbers that belong to the site.
            extension_type: The type of extension where the phone number belongs.
            keyword: A search keyword for phone or extension numbers.
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token is used to paginate through large result sets. A next page token will be returned whenever the set o

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if selected is not None:
            query_params['selected'] = str(selected).lower()
        if site_id is not None:
            query_params['site_id'] = site_id
        if extension_type is not None:
            query_params['extension_type'] = extension_type
        if keyword is not None:
            query_params['keyword'] = keyword
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/phone/users/{userId}/outbound_caller_id/customized_numbers".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_user_customize_outbound_caller_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_user_customize_outbound_caller_numbers")

    async def add_user_outbound_caller_numbers(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add phone numbers for users' customized outbound caller ID

        HTTP POST /phone/users/{userId}/outbound_caller_id/customized_numbers

        Args:
            userId: The unique identifier of the user.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/outbound_caller_id/customized_numbers".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_user_outbound_caller_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_user_outbound_caller_numbers")

    async def delete_user_outbound_caller_numbers(
        self,
        userId: str,
        customize_ids: list[object] | None = None
    ) -> ZoomResponse:
        """Remove users' customized outbound caller ID phone numbers

        HTTP DELETE /phone/users/{userId}/outbound_caller_id/customized_numbers

        Args:
            userId: The unique identifier of the user.
            customize_ids: The customization IDs.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if customize_ids is not None:
            query_params['customize_ids'] = customize_ids

        url = self.base_url + "/phone/users/{userId}/outbound_caller_id/customized_numbers".format(userId=userId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_user_outbound_caller_numbers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_user_outbound_caller_numbers")

    async def get_user_policy_details(
        self,
        userId: str,
        policyType: str
    ) -> ZoomResponse:
        """Get user policy details

        HTTP GET /phone/users/{userId}/policies/{policyType}

        Args:
            userId: The user ID.
            policyType: This field specifies the type of policy to retrieve or modify. See the documentation for detailed behavior of each polic

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/policies/{policyType}".format(userId=userId, policyType=policyType)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_user_policy_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_user_policy_details")

    async def update_user_policy(
        self,
        userId: str,
        policyType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update user policy

        HTTP PATCH /phone/users/{userId}/policies/{policyType}

        Args:
            userId: The user ID.
            policyType: This field specifies the type of policy to retrieve or modify. See the documentation for detailed behavior of each polic
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/policies/{policyType}".format(userId=userId, policyType=policyType)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_user_policy" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_user_policy")

    async def phone_user_settings(
        self,
        userId: str
    ) -> ZoomResponse:
        """Get a user's profile settings

        HTTP GET /phone/users/{userId}/settings

        Args:
            userId: The user ID or email address of the user. For user-level apps, pass `me` as the value for userId.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/settings".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed phone_user_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute phone_user_settings")

    async def update_user_settings(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a user's profile settings

        HTTP PATCH /phone/users/{userId}/settings

        Args:
            userId: The user ID or email address of the user. For user-level apps, pass `me` as the value for userId.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/settings".format(userId=userId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_user_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_user_settings")

    async def add_user_setting(
        self,
        userId: str,
        settingType: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a user's shared access setting

        HTTP POST /phone/users/{userId}/settings/{settingType}

        Args:
            userId: The unique identifier of the user.
            settingType: This field corresponds to the setting item you wish to modify. Allowed values: `voice_mail`, `delegation`, `desk_phone`,
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/settings/{settingType}".format(userId=userId, settingType=settingType)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_user_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_user_setting")

    async def delete_user_setting(
        self,
        userId: str,
        settingType: str,
        shared_id: str | None = None,
        assistant_extension_id: str | None = None,
        device_id: str | None = None,
        intercom_extension_id: str | None = None
    ) -> ZoomResponse:
        """Delete a user's shared access setting

        HTTP DELETE /phone/users/{userId}/settings/{settingType}

        Args:
            userId: The unique identifier of the user.
            settingType: Corresponds to the setting item you wish to remove. Allowed values: `voice_mail`, `delegation`, `desk_phone`, `intercom`
            shared_id: This field is required only for voicemail, auto_call_recording, and ad_hoc_call_recording setting type.
            assistant_extension_id: This field deletes the delegation assistant, used for delegation setting type.
            device_id: This field deletes the assigned device, used for `desk_phone` setting type.
            intercom_extension_id: This field deletes the intercom connection for the `intercom` setting type.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if shared_id is not None:
            query_params['shared_id'] = shared_id
        if assistant_extension_id is not None:
            query_params['assistant_extension_id'] = assistant_extension_id
        if device_id is not None:
            query_params['device_id'] = device_id
        if intercom_extension_id is not None:
            query_params['intercom_extension_id'] = intercom_extension_id

        url = self.base_url + "/phone/users/{userId}/settings/{settingType}".format(userId=userId, settingType=settingType)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_user_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_user_setting")

    async def update_user_setting(
        self,
        settingType: str,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a user's shared access setting

        HTTP PATCH /phone/users/{userId}/settings/{settingType}

        Args:
            settingType: This field corresponds to the setting item you wish to modify. Allowed values: `voice_mail`, `delegation`, `desk_phone`,
            userId: The unique identifier of the user.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/settings/{settingType}".format(settingType=settingType, userId=userId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_user_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_user_setting")

    async def get_voicemail_details_by_call_id_or_call_log_id(
        self,
        userId: str,
        id_: str
    ) -> ZoomResponse:
        """Get user voicemail details from a call log

        HTTP GET /phone/users/{userId}/call_logs/{id}/voice_mail

        Args:
            userId: The user ID or email address of the user.
            id_: The unique ID of the call log. You can use `callLogId` or `callId` as path parameters.  You can find the value for this

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/users/{userId}/call_logs/{id_}/voice_mail".format(userId=userId, id_=id_)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_voicemail_details_by_call_id_or_call_log_id" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_voicemail_details_by_call_id_or_call_log_id")

    async def phone_user_voice_mails(
        self,
        userId: str,
        *,
        page_size: int | None = None,
        status: str | None = None,
        next_page_token: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        trash: bool | None = None
    ) -> ZoomResponse:
        """Get user's voicemails

        HTTP GET /phone/users/{userId}/voice_mails

        Args:
            userId: The user ID or email address of the user. For user-level apps, pass `me` as the value for userId.
            page_size: The number of records returned within a single API call.
            status: The status of the voice mail.
            next_page_token: The next page token paginates through large result sets. A next page token returns whenever the set of available results
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format. The date range defined by the `from` a
            to: **Required** only when the `from` parameter is specified. End time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss
            trash: Whether to query voicemails from trash.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if status is not None:
            query_params['status'] = status
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if trash is not None:
            query_params['trash'] = str(trash).lower()

        url = self.base_url + "/phone/users/{userId}/voice_mails".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed phone_user_voice_mails" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute phone_user_voice_mails")

    async def account_voice_mails(
        self,
        *,
        page_size: int | None = None,
        status: str | None = None,
        site_id: str | None = None,
        owner_type: str | None = None,
        voicemail_type: str | None = None,
        next_page_token: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        trashed: bool | None = None
    ) -> ZoomResponse:
        """Get account voicemails

        HTTP GET /phone/voice_mails

        Args:
            page_size: The number of records returned within a single API call.
            status: The status of the voice mail.
            site_id: The site ID.
            owner_type: The owner type.   The allowed values are `null`, `user`, `callQueue`, `sharedLineGroup`, `autoReceptionist`, or `sharedO
            voicemail_type: The voicemail type.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            from_: The start time and date in **yyyy-mm-dd** or **yyyy-MM-dd'T'HH:mm:ss'Z'** format.   The date range defined in the `from`
            to: This field is **required** only when the `from` parameter is specified.   The end time and date in **yyyy-mm-dd** or **y
            trashed: Whether to query voicemails from trash. The default setting is false.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if status is not None:
            query_params['status'] = status
        if site_id is not None:
            query_params['site_id'] = site_id
        if owner_type is not None:
            query_params['owner_type'] = owner_type
        if voicemail_type is not None:
            query_params['voicemail_type'] = voicemail_type
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if trashed is not None:
            query_params['trashed'] = str(trashed).lower()

        url = self.base_url + "/phone/voice_mails"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed account_voice_mails" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute account_voice_mails")

    async def phone_download_voicemail_file(
        self,
        fileId: str
    ) -> ZoomResponse:
        """Download a phone voicemail

        HTTP GET /phone/voice_mails/download/{fileId}

        Args:
            fileId: The file ID of the phone voicemail.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/voice_mails/download/{fileId}".format(fileId=fileId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed phone_download_voicemail_file" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute phone_download_voicemail_file")

    async def get_voicemail_details(
        self,
        voicemailId: str
    ) -> ZoomResponse:
        """Get voicemail details

        HTTP GET /phone/voice_mails/{voicemailId}

        Args:
            voicemailId: The unique identifier of the voicemail. It retrieves the value for this field by calling the [Get voicemails](https://ma

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/voice_mails/{voicemailId}".format(voicemailId=voicemailId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_voicemail_details" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_voicemail_details")

    async def delete_voicemail(
        self,
        voicemailId: str
    ) -> ZoomResponse:
        """Delete a voicemail

        HTTP DELETE /phone/voice_mails/{voicemailId}

        Args:
            voicemailId: The unique identifier of the voicemail. It retrieves the value for this field by calling the [Get voicemails](https://ma

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/voice_mails/{voicemailId}".format(voicemailId=voicemailId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_voicemail" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_voicemail")

    async def update_voicemail_read_status(
        self,
        voicemailId: str,
        read_status: str | None = None
    ) -> ZoomResponse:
        """Update Voicemail Read Status

        HTTP PATCH /phone/voice_mails/{voicemailId}

        Args:
            voicemailId: The unique identifier of the voicemail. It retrieves the value for this field by calling the [Get voicemails](https://ma
            read_status: The voicemail status. The `Unread` feature must enable **Mark Voicemail as Unread**.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if read_status is not None:
            query_params['read_status'] = read_status

        url = self.base_url + "/phone/voice_mails/{voicemailId}".format(voicemailId=voicemailId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_voicemail_read_status" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_voicemail_read_status")

    async def list_zoom_rooms(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        site_id: str | None = None,
        calling_type: int | None = None,
        keyword: str | None = None
    ) -> ZoomResponse:
        """List Zoom Rooms under Zoom Phone license

        HTTP GET /phone/rooms

        Args:
            page_size: The number of records returned from a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            site_id: The site ID retrievable from the [List Phone Sites](https://marketplace.zoom.us/docs/api-reference/phone/methods#operati
            calling_type: The type of calling plan.
            keyword: The Zoom room name or phone number from which to filter the results .

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if site_id is not None:
            query_params['site_id'] = site_id
        if calling_type is not None:
            query_params['calling_type'] = str(calling_type)
        if keyword is not None:
            query_params['keyword'] = keyword

        url = self.base_url + "/phone/rooms"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_zoom_rooms" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_zoom_rooms")

    async def add_zoom_room(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a Zoom Room to a Zoom Phone

        HTTP POST /phone/rooms

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/rooms"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_zoom_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_zoom_room")

    async def list_unassigned_zoom_rooms(
        self,
        keyword: str | None = None
    ) -> ZoomResponse:
        """List Zoom Rooms without Zoom Phone assignment

        HTTP GET /phone/rooms/unassigned

        Args:
            keyword: A search keyword for Zoom Room's name.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if keyword is not None:
            query_params['keyword'] = keyword

        url = self.base_url + "/phone/rooms/unassigned"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_unassigned_zoom_rooms" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_unassigned_zoom_rooms")

    async def get_zoom_room(
        self,
        roomId: str
    ) -> ZoomResponse:
        """Get a Zoom Room under Zoom Phone license

        HTTP GET /phone/rooms/{roomId}

        Args:
            roomId: Path parameter

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/rooms/{roomId}".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_zoom_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_zoom_room")

    async def remove_zoom_room(
        self,
        roomId: str
    ) -> ZoomResponse:
        """Remove a Zoom Room from a ZP account

        HTTP DELETE /phone/rooms/{roomId}

        Args:
            roomId: Path parameter

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/rooms/{roomId}".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed remove_zoom_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute remove_zoom_room")

    async def update_zoom_room(
        self,
        roomId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a Zoom Room under Zoom Phone license

        HTTP PATCH /phone/rooms/{roomId}

        Args:
            roomId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/rooms/{roomId}".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_zoom_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_zoom_room")

    async def assign_calling_plan_to_room(
        self,
        roomId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign calling plans to a Zoom Room

        HTTP POST /phone/rooms/{roomId}/calling_plans

        Args:
            roomId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/rooms/{roomId}/calling_plans".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assign_calling_plan_to_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assign_calling_plan_to_room")

    async def unassign_calling_plan_from_room(
        self,
        roomId: str,
        type_: str,
        billing_account_id: str | None = None
    ) -> ZoomResponse:
        """Remove a calling plan from a Zoom Room

        HTTP DELETE /phone/rooms/{roomId}/calling_plans/{type}

        Args:
            roomId: Path parameter
            type_: The [type](https://marketplace.zoom.us/docs/api-reference/other-references/plans#zoom-phone-calling-plans) of the callin
            billing_account_id: The billing account ID. If the zoom room is located in India, the parameter is required.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if billing_account_id is not None:
            query_params['billing_account_id'] = billing_account_id

        url = self.base_url + "/phone/rooms/{roomId}/calling_plans/{type_}".format(roomId=roomId, type_=type_)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed unassign_calling_plan_from_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute unassign_calling_plan_from_room")

    async def assign_phone_number_to_zoom_room(
        self,
        roomId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign phone numbers to a Zoom Room

        HTTP POST /phone/rooms/{roomId}/phone_numbers

        Args:
            roomId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/rooms/{roomId}/phone_numbers".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assign_phone_number_to_zoom_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assign_phone_number_to_zoom_room")

    async def unassign_phone_number_from_zoom_room(
        self,
        roomId: str,
        phoneNumberId: str
    ) -> ZoomResponse:
        """Remove a phone number from a Zoom Room

        HTTP DELETE /phone/rooms/{roomId}/phone_numbers/{phoneNumberId}

        Args:
            roomId: Provide roomId of the Zoom Room.
            phoneNumberId: Provide phoneNumberId of the Zoom Room.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/phone/rooms/{roomId}/phone_numbers/{phoneNumberId}".format(roomId=roomId, phoneNumberId=phoneNumberId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed unassign_phone_number_from_zoom_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute unassign_phone_number_from_zoom_room")

    async def dashboard_meeting_participants_qos_summary(
        self,
        meetingId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List meeting participants QoS Summary

        HTTP GET /metrics/meetings/{meetingId}/participants/qos_summary

        Args:
            meetingId: The meeting's ID or universally unique ID (UUID). * If you provide a meeting ID, the API will return a response for the
            page_size: The number of items returned per page.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/metrics/meetings/{meetingId}/participants/qos_summary".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_meeting_participants_qos_summary" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_meeting_participants_qos_summary")

    async def dashboard_webinar_participants_qos_summary(
        self,
        webinarId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List webinar participants QoS Summary

        HTTP GET /metrics/webinars/{webinarId}/participants/qos_summary

        Args:
            webinarId: The webinar's ID or universally unique ID (UUID). * If you provide a webinar ID, the API will return a response for the
            page_size: The number of items returned per page.
            next_page_token: The next page token is used to paginate through large result sets. A next page token will be returned whenever the set o

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/metrics/webinars/{webinarId}/participants/qos_summary".format(webinarId=webinarId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed dashboard_webinar_participants_qos_summary" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute dashboard_webinar_participants_qos_summary")

    async def session_users_qos_summary(
        self,
        sessionId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List session users QoS Summary

        HTTP GET /videosdk/sessions/{sessionId}/users/qos_summary

        Args:
            sessionId: The session's ID. If the ID begins with a `/` character or contains `//` characters, you must **double-encode** the ID v
            page_size: The number of items returned per page.
            next_page_token: The next page token used to paginate through large result sets. A next page token will be returned whenever the set of a

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/videosdk/sessions/{sessionId}/users/qos_summary".format(sessionId=sessionId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed session_users_qos_summary" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute session_users_qos_summary")

    async def config_zoom_room_controller_apps(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Config Zoom Room Controller Apps

        HTTP POST /rooms/controller/apps/config

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/controller/apps/config"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed config_zoom_room_controller_apps" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute config_zoom_room_controller_apps")

    async def invitation_list(
        self,
        invite_location_id: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        data_scope: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """Get a list of visitors by location

        HTTP GET /visitor/invitation

        Args:
            invite_location_id: The location ID where the visitor is invited to.
            from_: The start time for visit time filtering.
            to: The end time for visit time filtering.
            data_scope: user: Only display the invitation records of this user. account: When having admin privileges, display the invitation re
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            page_size: The number of records returned within a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if invite_location_id is not None:
            query_params['invite_location_id'] = invite_location_id
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if data_scope is not None:
            query_params['data_scope'] = data_scope
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/visitor/invitation"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed invitation_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute invitation_list")

    async def create_invitation(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Send an invitation

        HTTP POST /visitor/invitation

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/visitor/invitation"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_invitation" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_invitation")

    async def get_invitation(
        self,
        invitationId: str
    ) -> ZoomResponse:
        """Invitation details by invitationID

        HTTP GET /visitor/invitation/{invitationId}

        Args:
            invitationId: The invitation ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/visitor/invitation/{invitationId}".format(invitationId=invitationId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_invitation" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_invitation")

    async def delete_invitation(
        self,
        invitationId: str,
        *,
        cancel: bool | None = None
    ) -> ZoomResponse:
        """Delete an Invitation

        HTTP DELETE /visitor/invitation/{invitationId}

        Args:
            invitationId: The invitation ID.
            cancel: True: cancel invitation; false: delete invitation.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if cancel is not None:
            query_params['cancel'] = str(cancel).lower()

        url = self.base_url + "/visitor/invitation/{invitationId}".format(invitationId=invitationId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_invitation" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_invitation")

    async def update_invitation(
        self,
        invitationId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update an invitation

        HTTP PATCH /visitor/invitation/{invitationId}

        Args:
            invitationId: The invitation ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/visitor/invitation/{invitationId}".format(invitationId=invitationId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_invitation" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_invitation")

    async def checkin_visitor(
        self,
        invitationId: str
    ) -> ZoomResponse:
        """Check in a visitor

        HTTP POST /visitor/invitation/{invitationId}/checkin

        Args:
            invitationId: The invitation ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/visitor/invitation/{invitationId}/checkin".format(invitationId=invitationId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed checkin_visitor" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute checkin_visitor")

    async def list_workspaces(
        self,
        location_id: str | None = None,
        workspace_name: str | None = None,
        workspace_type: str | None = None,
        reserve_user: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List workspaces

        HTTP GET /workspaces

        Args:
            location_id: The location's ID.
            workspace_name: The name of the desk.
            workspace_type: The type of workspace. Default will return desk and room if it is empty.
            reserve_user: The user who wants to reserve workspace, default will be the user who request.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if location_id is not None:
            query_params['location_id'] = location_id
        if workspace_name is not None:
            query_params['workspace_name'] = workspace_name
        if workspace_type is not None:
            query_params['workspace_type'] = workspace_type
        if reserve_user is not None:
            query_params['reserve_user'] = reserve_user
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/workspaces"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_workspaces" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_workspaces")

    async def create_workspace(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a workspace

        HTTP POST /workspaces

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_workspace" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_workspace")

    async def getaworkspaceadditionalenhancements(
        self,
        from_: str | None = None,
        to: str | None = None,
        reserve_user: str | None = None,
        location_id: str | None = None,
        workspace_type: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List workspace additional information with time range

        HTTP GET /workspaces/additional_informations

        Args:
            from_: The start date of the query.
            to: The end date of the query. Can be up to 14 days in the future.
            reserve_user: The user who wants to reserve workspace, default will be the user who request
            location_id: The location's ID.
            workspace_type: The type of workspace. Default will return desk and room if it is empty.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if reserve_user is not None:
            query_params['reserve_user'] = reserve_user
        if location_id is not None:
            query_params['location_id'] = location_id
        if workspace_type is not None:
            query_params['workspace_type'] = workspace_type
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/workspaces/additional_informations"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getaworkspaceadditionalenhancements" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getaworkspaceadditionalenhancements")

    async def getallworkspaceassets(
        self,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """Get all workspace assets

        HTTP GET /workspaces/assets

        Args:
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            page_size: The number of records returned within a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/workspaces/assets"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getallworkspaceassets" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getallworkspaceassets")

    async def adda_workspaceasset(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a workspace asset

        HTTP POST /workspaces/assets

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/assets"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed adda_workspaceasset" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute adda_workspaceasset")

    async def get_workspace_asset(
        self,
        assetId: str
    ) -> ZoomResponse:
        """Get a workspace asset

        HTTP GET /workspaces/assets/{assetId}

        Args:
            assetId: Unique ID that represents the workspace asset.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/assets/{assetId}".format(assetId=assetId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_workspace_asset" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_workspace_asset")

    async def deletea_workspaceasset(
        self,
        assetId: str
    ) -> ZoomResponse:
        """Delete a workspace asset

        HTTP DELETE /workspaces/assets/{assetId}

        Args:
            assetId: A unique ID that represents the workspace asset.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/assets/{assetId}".format(assetId=assetId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed deletea_workspaceasset" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute deletea_workspaceasset")

    async def patch_workspaceasset(
        self,
        assetId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Edit a workspace asset

        HTTP PATCH /workspaces/assets/{assetId}

        Args:
            assetId: The unique ID of an asset that needs to be edited.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/assets/{assetId}".format(assetId=assetId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed patch_workspaceasset" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute patch_workspaceasset")

    async def reservation_event(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Check in/out of a reservation

        HTTP POST /workspaces/events

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/events"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed reservation_event" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute reservation_event")

    async def add_or_update_a_workspace_floor_map(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add or Update a Workspace floor map

        HTTP POST /workspaces/floormap/files

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/floormap/files"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_or_update_a_workspace_floor_map" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_or_update_a_workspace_floor_map")

    async def update_workspace_settings(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update workspace settings

        HTTP PATCH /workspaces/settings

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/settings"

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_workspace_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_workspace_settings")

    async def get_hot_desk_usage(
        self,
        location_id: str | None = None
    ) -> ZoomResponse:
        """Get a location's hot desk usage

        HTTP GET /workspaces/usage

        Args:
            location_id: The location's ID.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if location_id is not None:
            query_params['location_id'] = location_id

        url = self.base_url + "/workspaces/usage"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_hot_desk_usage" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_hot_desk_usage")

    async def get_workspace_calendar_free_busy_event(
        self,
        userId: str
    ) -> ZoomResponse:
        """Get  Workspace Calendar Free/Busy Event

        HTTP GET /workspaces/users/{userId}/calendar/settings

        Args:
            userId: The user ID of the user whose setting needs to be retrieved.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/users/{userId}/calendar/settings".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_workspace_calendar_free_busy_event" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_workspace_calendar_free_busy_event")

    async def set_calendar_free_busy_event(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Set Workspace Calendar Free/Busy Event

        HTTP POST /workspaces/users/{userId}/calendar/settings

        Args:
            userId: The unique identifier for a user whose workspace calendar settings needs to be updated.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/users/{userId}/calendar/settings".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed set_calendar_free_busy_event" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute set_calendar_free_busy_event")

    async def user_list_reservations(
        self,
        userId: str,
        from_: str | None = None,
        to: str | None = None
    ) -> ZoomResponse:
        """Get a user's workspace's reservations

        HTTP GET /workspaces/users/{userId}/reservations

        Args:
            userId: The user ID.
            from_: The start date of the query.
            to: The end date of the query. Can be up to 14 days.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to

        url = self.base_url + "/workspaces/users/{userId}/reservations".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_list_reservations" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_list_reservations")

    async def delete_workspace_floor_map(
        self,
        locationId: str,
        *,
        remove_child: bool | None = None
    ) -> ZoomResponse:
        """Delete Workspace floor map

        HTTP DELETE /workspaces/{locationId}/background

        Args:
            locationId: Location ID of the place where the Zoom Room was added.
            remove_child: Whether workspace shapes and wayfinding need to be removed, false by default.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if remove_child is not None:
            query_params['remove_child'] = str(remove_child).lower()

        url = self.base_url + "/workspaces/{locationId}/background".format(locationId=locationId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_workspace_floor_map" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_workspace_floor_map")

    async def get_workspace(
        self,
        workspaceId: str
    ) -> ZoomResponse:
        """Get a workspace

        HTTP GET /workspaces/{workspaceId}

        Args:
            workspaceId: The workspace's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/{workspaceId}".format(workspaceId=workspaceId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_workspace" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_workspace")

    async def delete_workspace(
        self,
        workspaceId: str
    ) -> ZoomResponse:
        """Delete a workspace

        HTTP DELETE /workspaces/{workspaceId}

        Args:
            workspaceId: The workspace's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/{workspaceId}".format(workspaceId=workspaceId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_workspace" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_workspace")

    async def update_workspace(
        self,
        workspaceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a workspace

        HTTP PATCH /workspaces/{workspaceId}

        Args:
            workspaceId: The workspace's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/{workspaceId}".format(workspaceId=workspaceId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_workspace" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_workspace")

    async def getadeskassignment(
        self,
        workspaceId: str
    ) -> ZoomResponse:
        """Get a desk assignment

        HTTP GET /workspaces/{workspaceId}/assignment

        Args:
            workspaceId: The workspace's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/{workspaceId}/assignment".format(workspaceId=workspaceId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getadeskassignment" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getadeskassignment")

    async def set_a_desk_assignment(
        self,
        workspaceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Set a desk assignment

        HTTP PUT /workspaces/{workspaceId}/assignment

        Args:
            workspaceId: The workspace's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/{workspaceId}/assignment".format(workspaceId=workspaceId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed set_a_desk_assignment" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute set_a_desk_assignment")

    async def deleteadeskassignment(
        self,
        workspaceId: str
    ) -> ZoomResponse:
        """Delete a desk assignment

        HTTP DELETE /workspaces/{workspaceId}/assignment

        Args:
            workspaceId: The workspace's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/{workspaceId}/assignment".format(workspaceId=workspaceId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed deleteadeskassignment" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute deleteadeskassignment")

    async def get_workspace_qr_code(
        self,
        workspaceId: str,
        type_: str | None = None,
        ttl: int | None = None
    ) -> ZoomResponse:
        """Get a workspace QR code

        HTTP GET /workspaces/{workspaceId}/qr_code

        Args:
            workspaceId: The workspace's ID.
            type_: The type of URL of QR code that you would like to retrieve.  `check_in`: Check-in QR code URL.  `unified`: Unified QR co
            ttl: The expiry time of the URL in seconds.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if ttl is not None:
            query_params['ttl'] = str(ttl)

        url = self.base_url + "/workspaces/{workspaceId}/qr_code".format(workspaceId=workspaceId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_workspace_qr_code" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_workspace_qr_code")

    async def list_reservations(
        self,
        workspaceId: str,
        from_: str | None = None,
        to: str | None = None,
        user_id: str | None = None
    ) -> ZoomResponse:
        """Get a workspace's reservations

        HTTP GET /workspaces/{workspaceId}/reservations

        Args:
            workspaceId: The workspace's ID.
            from_: The start date of the query.
            to: The end date of the query. Can be up to 14 days in the future.
            user_id: The ID of the user for whom to create a workspace reservation.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if user_id is not None:
            query_params['user_id'] = user_id

        url = self.base_url + "/workspaces/{workspaceId}/reservations".format(workspaceId=workspaceId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_reservations" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_reservations")

    async def create_reservation(
        self,
        workspaceId: str,
        body: dict[str, Any],
        *,
        check_in: bool | None = None
    ) -> ZoomResponse:
        """Create a reservation

        HTTP POST /workspaces/{workspaceId}/reservations

        Args:
            workspaceId: The workspace's ID.
            body: Request body payload
            check_in: Check in this reservation after successful creation.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if check_in is not None:
            query_params['check_in'] = str(check_in).lower()

        url = self.base_url + "/workspaces/{workspaceId}/reservations".format(workspaceId=workspaceId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_reservation" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_reservation")

    async def get_getaworkspacereservationbyreservation_id(
        self,
        workspaceId: str,
        reservationId: str
    ) -> ZoomResponse:
        """Get a workspace reservation by reservationId

        HTTP GET /workspaces/{workspaceId}/reservations/{reservationId}

        Args:
            workspaceId: Workspace ID.
            reservationId: Reservation ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/{workspaceId}/reservations/{reservationId}".format(workspaceId=workspaceId, reservationId=reservationId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_getaworkspacereservationbyreservation_id" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_getaworkspacereservationbyreservation_id")

    async def delete_reservation(
        self,
        workspaceId: str,
        reservationId: str
    ) -> ZoomResponse:
        """Delete a reservation

        HTTP DELETE /workspaces/{workspaceId}/reservations/{reservationId}

        Args:
            workspaceId: The workspace's ID.
            reservationId: The reservation's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/{workspaceId}/reservations/{reservationId}".format(workspaceId=workspaceId, reservationId=reservationId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_reservation" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_reservation")

    async def update_reservation(
        self,
        workspaceId: str,
        reservationId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a reservation

        HTTP PATCH /workspaces/{workspaceId}/reservations/{reservationId}

        Args:
            workspaceId: The workspace's ID.
            reservationId: The reservation's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/workspaces/{workspaceId}/reservations/{reservationId}".format(workspaceId=workspaceId, reservationId=reservationId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_reservation" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_reservation")

    async def listworkspacereservationquestionnaires(
        self,
        workspaceId: str,
        reservationId: str,
        subject: str | None = None
    ) -> ZoomResponse:
        """List workspace reservation questionnaires

        HTTP GET /workspaces/{workspaceId}/reservations/{reservationId}/questionnaires

        Args:
            workspaceId: The workspace's ID.
            reservationId: The reservation's ID.
            subject: The questionnaire's subject.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if subject is not None:
            query_params['subject'] = subject

        url = self.base_url + "/workspaces/{workspaceId}/reservations/{reservationId}/questionnaires".format(workspaceId=workspaceId, reservationId=reservationId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed listworkspacereservationquestionnaires" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute listworkspacereservationquestionnaires")

    async def list_zoom_rooms_1(
        self,
        *,
        status: str | None = None,
        tag_ids: str | None = None,
        type_: str | None = None,
        unassigned_rooms: bool | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        location_id: str | None = None,
        query_name: str | None = None
    ) -> ZoomResponse:
        """List Zoom Rooms

        HTTP GET /rooms

        Args:
            status: The status of the Zoom Room.
            tag_ids: The room tag IDs associated with the Zoom Room. Use commas (,) to separate between them. It's 'OR' logic if query for mu
            type_: The type of Zoom Rooms .
            unassigned_rooms: Use this query parameter with a value of `true` if you would like to see Zoom Rooms in your account that have not been a
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            location_id: The parent location ID of the Zoom Room.
            query_name: The name of a Zoom Room. If you do not call this parameter, the API will return all of the account's Zoom Rooms.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if status is not None:
            query_params['status'] = status
        if tag_ids is not None:
            query_params['tag_ids'] = tag_ids
        if type_ is not None:
            query_params['type'] = type_
        if unassigned_rooms is not None:
            query_params['unassigned_rooms'] = str(unassigned_rooms).lower()
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if location_id is not None:
            query_params['location_id'] = location_id
        if query_name is not None:
            query_params['query_name'] = query_name

        url = self.base_url + "/rooms"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_zoom_rooms_1" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_zoom_rooms_1")

    async def add_a_room(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a Zoom Room

        HTTP POST /rooms

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_a_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_a_room")

    async def list_digital_signage_content(
        self,
        type_: str | None = None,
        folder_id: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List digital signage contents

        HTTP GET /rooms/digital_signage

        Args:
            type_: Specify the type of digital signage resource. The value can be one of the following: * `content`: Returns information ab
            folder_id: Unique identifier of the folder where the content is located. Provide this field if you would like to filter the respons
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if folder_id is not None:
            query_params['folder_id'] = folder_id
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/rooms/digital_signage"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_digital_signage_content" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_digital_signage_content")

    async def manage_e911signage(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update E911 digital signage

        HTTP PATCH /rooms/events

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/events"

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed manage_e911signage" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute manage_e911signage")

    async def zoom_rooms_controls(
        self,
        id_: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Use Zoom Room controls

        HTTP PATCH /rooms/{id}/events

        Args:
            id_: The room ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/{id_}/events".format(id_=id_)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed zoom_rooms_controls" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute zoom_rooms_controls")

    async def get_zr_settings(
        self,
        id_: str,
        setting_type: str | None = None
    ) -> ZoomResponse:
        """Get Zoom Room settings

        HTTP GET /rooms/{id}/settings

        Args:
            id_: Unique Identifier of the Zoom Room.
            setting_type: The type of setting that you would like to retrieve.  `alert`: Alert settings of the Zoom Room.  `meeting`: Meeting sett

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if setting_type is not None:
            query_params['setting_type'] = setting_type

        url = self.base_url + "/rooms/{id_}/settings".format(id_=id_)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_zr_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_zr_settings")

    async def update_zr_settings(
        self,
        id_: str,
        body: dict[str, Any],
        setting_type: str | None = None
    ) -> ZoomResponse:
        """Update Zoom Room settings

        HTTP PATCH /rooms/{id}/settings

        Args:
            id_: Unique Identifier of the Zoom Room.
            body: Request body payload
            setting_type: The type of setting that you would like to update.  `alert`: Alert settings of the Zoom Room.  `meeting`: Meeting settin

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if setting_type is not None:
            query_params['setting_type'] = setting_type

        url = self.base_url + "/rooms/{id_}/settings".format(id_=id_)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_zr_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_zr_settings")

    async def get_zr_profile(
        self,
        roomId: str,
        *,
        regenerate_activation_code: bool | None = None
    ) -> ZoomResponse:
        """Get Zoom Room profile

        HTTP GET /rooms/{roomId}

        Args:
            roomId: The unique identifier of the Zoom Room. This can be retrieved from the response of the [**List Zoom Rooms**](https://dev
            regenerate_activation_code: Whether to regenerate an activation code for a Zoom Room. Default is `false`.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if regenerate_activation_code is not None:
            query_params['regenerate_activation_code'] = str(regenerate_activation_code).lower()

        url = self.base_url + "/rooms/{roomId}".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_zr_profile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_zr_profile")

    async def delete_a_zoom_room(
        self,
        roomId: str
    ) -> ZoomResponse:
        """Delete a Zoom Room

        HTTP DELETE /rooms/{roomId}

        Args:
            roomId: Unique identifier of a Zoom Room.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/{roomId}".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_a_zoom_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_a_zoom_room")

    async def update_room_profile(
        self,
        roomId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a Zoom Room profile

        HTTP PATCH /rooms/{roomId}

        Args:
            roomId: The unique identifier of a Zoom Room.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/{roomId}".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_room_profile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_room_profile")

    async def get_room_profiles(
        self,
        roomId: str
    ) -> ZoomResponse:
        """List device profiles

        HTTP GET /rooms/{roomId}/device_profiles

        Args:
            roomId: The Zoom Room's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/{roomId}/device_profiles".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_room_profiles" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_room_profiles")

    async def create_room_device_profile(
        self,
        roomId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a device profile

        HTTP POST /rooms/{roomId}/device_profiles

        Args:
            roomId: The Zoom Room's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/{roomId}/device_profiles".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_room_device_profile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_room_device_profile")

    async def get_room_devices(
        self,
        roomId: str
    ) -> ZoomResponse:
        """Get device information

        HTTP GET /rooms/{roomId}/device_profiles/devices

        Args:
            roomId: The Zoom Room's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/{roomId}/device_profiles/devices".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_room_devices" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_room_devices")

    async def get_room_profile(
        self,
        roomId: str,
        deviceProfileId: str
    ) -> ZoomResponse:
        """Get a device profile

        HTTP GET /rooms/{roomId}/device_profiles/{deviceProfileId}

        Args:
            roomId: The Zoom Room's ID.
            deviceProfileId: The Zoom Room device profile's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/{roomId}/device_profiles/{deviceProfileId}".format(roomId=roomId, deviceProfileId=deviceProfileId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_room_profile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_room_profile")

    async def delete_room_profile(
        self,
        roomId: str,
        deviceProfileId: str
    ) -> ZoomResponse:
        """Delete a device profile

        HTTP DELETE /rooms/{roomId}/device_profiles/{deviceProfileId}

        Args:
            roomId: The Zoom Room's ID.
            deviceProfileId: The Zoom Room device profile's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/{roomId}/device_profiles/{deviceProfileId}".format(roomId=roomId, deviceProfileId=deviceProfileId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_room_profile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_room_profile")

    async def update_device_profile(
        self,
        roomId: str,
        deviceProfileId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a device profile

        HTTP PATCH /rooms/{roomId}/device_profiles/{deviceProfileId}

        Args:
            roomId: The Zoom Room's ID.
            deviceProfileId: The Zoom Room device profile's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/{roomId}/device_profiles/{deviceProfileId}".format(roomId=roomId, deviceProfileId=deviceProfileId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_device_profile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_device_profile")

    async def list_zr_devices(
        self,
        roomId: str
    ) -> ZoomResponse:
        """List Zoom Room devices

        HTTP GET /rooms/{roomId}/devices

        Args:
            roomId: Unique Identifier of the Zoom Room. This can be retrieved from the response of [**List Zoom Rooms**](/docs/api-reference

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/{roomId}/devices".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_zr_devices" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_zr_devices")

    async def change_zr_location(
        self,
        roomId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Change a Zoom Room's location

        HTTP PUT /rooms/{roomId}/location

        Args:
            roomId: Unique Identifier of the Zoom Room.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/{roomId}/location".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed change_zr_location" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute change_zr_location")

    async def get_zr_sensor_data(
        self,
        roomId: str,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        device_id: str | None = None,
        sensor_type: str | None = None
    ) -> ZoomResponse:
        """Get Zoom Room sensor data

        HTTP GET /rooms/{roomId}/sensor_data

        Args:
            roomId: Unique identifier of the Zoom Room. This can be retrieved from the response of the [**List Zoom Rooms**](https://develop
            from_: The start time and date in 'yyyy-MM-ddTHH:dd:ssZ' format.
            to: The end time and date in 'yyyy-MM-ddTHH:dd:ssZ' format.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab
            device_id: Query parameter
            sensor_type: Query parameter

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if device_id is not None:
            query_params['device_id'] = device_id
        if sensor_type is not None:
            query_params['sensor_type'] = sensor_type

        url = self.base_url + "/rooms/{roomId}/sensor_data".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_zr_sensor_data" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_zr_sensor_data")

    async def get_webzrc_url(
        self,
        roomId: str,
        *,
        pre_authenticated_link: bool | None = None
    ) -> ZoomResponse:
        """Get Zoom Rooms virtual controller URL

        HTTP GET /rooms/{roomId}/virtual_controller

        Args:
            roomId: The unique identifier of the Zoom Room. This can be retrieved from the response of the List Zoom Rooms API.
            pre_authenticated_link: If true, the URL for the virtual controller will contain a time-limited authentication token (10 minute lifetime) that w

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if pre_authenticated_link is not None:
            query_params['pre_authenticated_link'] = str(pre_authenticated_link).lower()

        url = self.base_url + "/rooms/{roomId}/virtual_controller".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_webzrc_url" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_webzrc_url")

    async def get_zr_account_profile(
        self
    ) -> ZoomResponse:
        """Get Zoom Room account profile

        HTTP GET /rooms/account_profile

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/account_profile"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_zr_account_profile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_zr_account_profile")

    async def update_zr_acc_profile(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update Zoom Room account profile

        HTTP PATCH /rooms/account_profile

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/account_profile"

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_zr_acc_profile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_zr_acc_profile")

    async def get_zr_account_settings(
        self,
        setting_type: str | None = None
    ) -> ZoomResponse:
        """Get Zoom Room account settings

        HTTP GET /rooms/account_settings

        Args:
            setting_type: The type of setting that you would like to retrieve.  `alert`: Alert settings of the Zoom Rooms Account.   `meeting`: Me

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if setting_type is not None:
            query_params['setting_type'] = setting_type

        url = self.base_url + "/rooms/account_settings"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_zr_account_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_zr_account_settings")

    async def update_zoom_room_acc_settings(
        self,
        body: dict[str, Any],
        setting_type: str | None = None
    ) -> ZoomResponse:
        """Update Zoom Room account settings

        HTTP PATCH /rooms/account_settings

        Args:
            body: Request body payload
            setting_type: The type of setting that you would like to update.    `alert`: Alert settings of the Zoom Rooms Account.   `meeting`: Me

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if setting_type is not None:
            query_params['setting_type'] = setting_type

        url = self.base_url + "/rooms/account_settings"

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_zoom_room_acc_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_zoom_room_acc_settings")

    async def get_calendar_services(
        self
    ) -> ZoomResponse:
        """List calendar services

        HTTP GET /rooms/calendar/services

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/calendar/services"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_calendar_services" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_calendar_services")

    async def delete_a_calendar_service(
        self,
        serviceId: str
    ) -> ZoomResponse:
        """Delete a calendar service

        HTTP DELETE /rooms/calendar/services/{serviceId}

        Args:
            serviceId: The calendar service's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/calendar/services/{serviceId}".format(serviceId=serviceId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_a_calendar_service" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_a_calendar_service")

    async def get_calendar_resources_by_service_id(
        self,
        serviceId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List calendar resources by calendar service

        HTTP GET /rooms/calendar/services/{serviceId}/resources

        Args:
            serviceId: The calendar service's ID.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/rooms/calendar/services/{serviceId}/resources".format(serviceId=serviceId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_calendar_resources_by_service_id" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_calendar_resources_by_service_id")

    async def add_a_calendar_resource_to_calendar_service(
        self,
        serviceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a calendar resource to a calendar service

        HTTP POST /rooms/calendar/services/{serviceId}/resources

        Args:
            serviceId: The calendar service's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/calendar/services/{serviceId}/resources".format(serviceId=serviceId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_a_calendar_resource_to_calendar_service" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_a_calendar_resource_to_calendar_service")

    async def get_calendar_resource_by_id(
        self,
        serviceId: str,
        resourceId: str
    ) -> ZoomResponse:
        """Get a calendar resource by ID

        HTTP GET /rooms/calendar/services/{serviceId}/resources/{resourceId}

        Args:
            serviceId: The calendar service's ID.
            resourceId: The calendar resource's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/calendar/services/{serviceId}/resources/{resourceId}".format(serviceId=serviceId, resourceId=resourceId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_calendar_resource_by_id" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_calendar_resource_by_id")

    async def delete_a_calendar_resource(
        self,
        serviceId: str,
        resourceId: str
    ) -> ZoomResponse:
        """Delete a calendar resource

        HTTP DELETE /rooms/calendar/services/{serviceId}/resources/{resourceId}

        Args:
            serviceId: The calendar service's ID.
            resourceId: The calendar resource's ID. You can get this value using the [**List Calendar Resources**](/docs/api-reference/zoom-api/

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/calendar/services/{serviceId}/resources/{resourceId}".format(serviceId=serviceId, resourceId=resourceId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_a_calendar_resource" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_a_calendar_resource")

    async def sync_a_calendar_service(
        self,
        serviceId: str
    ) -> ZoomResponse:
        """Start calendar service sync process

        HTTP PUT /rooms/calendar/services/{serviceId}/sync

        Args:
            serviceId: The calendar service's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/calendar/services/{serviceId}/sync".format(serviceId=serviceId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed sync_a_calendar_service" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute sync_a_calendar_service")

    async def list_zoom_roomsbackgroundimagelibrarycontents(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        folder_id: str | None = None
    ) -> ZoomResponse:
        """List Zoom Rooms background image library contents

        HTTP GET /rooms/content/background/contents

        Args:
            page_size: Page Size (number of file contents items).
            next_page_token: The next page token is used to paginate through large result sets. A next page token will be returned whenever the set o
            folder_id: The folder ID.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if folder_id is not None:
            query_params['folder_id'] = folder_id

        url = self.base_url + "/rooms/content/background/contents"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_zoom_roomsbackgroundimagelibrarycontents" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_zoom_roomsbackgroundimagelibrarycontents")

    async def get_zoom_rooms_background_image_library_content(
        self,
        contentId: str
    ) -> ZoomResponse:
        """Get Zoom Rooms background image library content

        HTTP GET /rooms/content/background/contents/{contentId}

        Args:
            contentId: The file content ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/background/contents/{contentId}".format(contentId=contentId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_zoom_rooms_background_image_library_content" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_zoom_rooms_background_image_library_content")

    async def delete_zoom_rooms_background_image_library_content(
        self,
        contentId: str
    ) -> ZoomResponse:
        """Delete Zoom Rooms Background Image Library Content

        HTTP DELETE /rooms/content/background/contents/{contentId}

        Args:
            contentId: The file content ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/background/contents/{contentId}".format(contentId=contentId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_zoom_rooms_background_image_library_content" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_zoom_rooms_background_image_library_content")

    async def list_default_zoom_rooms_background_image_librarycontents(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List default Zoom Rooms background image library contents

        HTTP GET /rooms/content/background/defaults

        Args:
            page_size: Page size, in number of file contents items.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/rooms/content/background/defaults"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_default_zoom_rooms_background_image_librarycontents" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_default_zoom_rooms_background_image_librarycontents")

    async def list_zoom_rooms_background_library_folders(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List Zoom Rooms Background Image Library Folders

        HTTP GET /rooms/content/background/folders

        Args:
            page_size: Page Size (Number of Folders).
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/rooms/content/background/folders"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_zoom_rooms_background_library_folders" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_zoom_rooms_background_library_folders")

    async def add_zoom_rooms_background_library_folder(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add Zoom Rooms Background Image Library Folder

        HTTP POST /rooms/content/background/folders

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/background/folders"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_zoom_rooms_background_library_folder" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_zoom_rooms_background_library_folder")

    async def get_zoom_rooms_background_library_folder(
        self,
        folderId: str
    ) -> ZoomResponse:
        """Get Zoom Rooms Background Image Library Folder

        HTTP GET /rooms/content/background/folders/{folderId}

        Args:
            folderId: The folder ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/background/folders/{folderId}".format(folderId=folderId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_zoom_rooms_background_library_folder" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_zoom_rooms_background_library_folder")

    async def delete_zoom_rooms_background_library_folder(
        self,
        folderId: str
    ) -> ZoomResponse:
        """Delete Zoom Rooms Background Image Library Folder

        HTTP DELETE /rooms/content/background/folders/{folderId}

        Args:
            folderId: The folder ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/background/folders/{folderId}".format(folderId=folderId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_zoom_rooms_background_library_folder" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_zoom_rooms_background_library_folder")

    async def updatea_zoom_rooms_background_library_folder_name(
        self,
        folderId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update Zoom Rooms Background Image Library Folder

        HTTP PATCH /rooms/content/background/folders/{folderId}

        Args:
            folderId: The folder ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/background/folders/{folderId}".format(folderId=folderId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed updatea_zoom_rooms_background_library_folder_name" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute updatea_zoom_rooms_background_library_folder_name")

    async def get_listdigitalsignagecontentitems(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List Digital Signage content items

        HTTP GET /rooms/content/digital_signage/contents

        Args:
            page_size: The number of records, returned within a single API call. Default: 30，Max: 200.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/rooms/content/digital_signage/contents"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_listdigitalsignagecontentitems" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_listdigitalsignagecontentitems")

    async def addadigitalsignage_url(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a digital signage URL

        HTTP POST /rooms/content/digital_signage/contents

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/digital_signage/contents"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed addadigitalsignage_url" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute addadigitalsignage_url")

    async def getdigitalsignagecontentitem(
        self,
        contentId: str
    ) -> ZoomResponse:
        """Get Digital Signage content item

        HTTP GET /rooms/content/digital_signage/contents/{contentId}

        Args:
            contentId: The content ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/digital_signage/contents/{contentId}".format(contentId=contentId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getdigitalsignagecontentitem" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getdigitalsignagecontentitem")

    async def deleteadigitalsignagecontentitem(
        self,
        contentId: str,
        *,
        remove_from_library_only: bool | None = None
    ) -> ZoomResponse:
        """Delete a Digital Signage content item

        HTTP DELETE /rooms/content/digital_signage/contents/{contentId}

        Args:
            contentId: Unique identifier of the digital signage content
            remove_from_library_only: If set to `true`, the content item will be removed from the content library only.  If set to `false`, the content item w

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if remove_from_library_only is not None:
            query_params['remove_from_library_only'] = str(remove_from_library_only).lower()

        url = self.base_url + "/rooms/content/digital_signage/contents/{contentId}".format(contentId=contentId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed deleteadigitalsignagecontentitem" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute deleteadigitalsignagecontentitem")

    async def updateadigitalsignagecontentitemattributes(
        self,
        contentId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a Digital Signage content item attributes

        HTTP PATCH /rooms/content/digital_signage/contents/{contentId}

        Args:
            contentId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/digital_signage/contents/{contentId}".format(contentId=contentId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed updateadigitalsignagecontentitemattributes" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute updateadigitalsignagecontentitemattributes")

    async def addadigitalsignagecontentfolder(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a digital signage content folder

        HTTP POST /rooms/content/digital_signage/folders

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/digital_signage/folders"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed addadigitalsignagecontentfolder" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute addadigitalsignagecontentfolder")

    async def getdigitalsignagecontentfolderdetails(
        self,
        folderId: str
    ) -> ZoomResponse:
        """Get Digital Signage content folder

        HTTP GET /rooms/content/digital_signage/folders/{folderId}

        Args:
            folderId: Unique identifier of the digital signage content folder.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/digital_signage/folders/{folderId}".format(folderId=folderId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getdigitalsignagecontentfolderdetails" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getdigitalsignagecontentfolderdetails")

    async def deleteadigitalsignagecontentfolder(
        self,
        folderId: str,
        *,
        remove_from_library_only: bool | None = None
    ) -> ZoomResponse:
        """Delete a Digital Signage content folder

        HTTP DELETE /rooms/content/digital_signage/folders/{folderId}

        Args:
            folderId: The folder ID.
            remove_from_library_only: If set to `true`, the folder and all its content item(s) will be removed from the content library only.  If set to `fals

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if remove_from_library_only is not None:
            query_params['remove_from_library_only'] = str(remove_from_library_only).lower()

        url = self.base_url + "/rooms/content/digital_signage/folders/{folderId}".format(folderId=folderId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed deleteadigitalsignagecontentfolder" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute deleteadigitalsignagecontentfolder")

    async def updateadigitalsignagecontentfolder(
        self,
        folderId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a digital signage content folder

        HTTP PATCH /rooms/content/digital_signage/folders/{folderId}

        Args:
            folderId: The folder ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/digital_signage/folders/{folderId}".format(folderId=folderId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed updateadigitalsignagecontentfolder" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute updateadigitalsignagecontentfolder")

    async def list_digital_signagelibraryplaylists(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List Digital Signage library playlists

        HTTP GET /rooms/content/digital_signage/playlists

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/rooms/content/digital_signage/playlists"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_digital_signagelibraryplaylists" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_digital_signagelibraryplaylists")

    async def adda_digital_signagelibraryplaylist(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a Digital Signage library playlist

        HTTP POST /rooms/content/digital_signage/playlists

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/digital_signage/playlists"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed adda_digital_signagelibraryplaylist" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute adda_digital_signagelibraryplaylist")

    async def get_digital_signagelibraryplaylist(
        self,
        playlistId: str
    ) -> ZoomResponse:
        """Get Digital Signage library playlist

        HTTP GET /rooms/content/digital_signage/playlists/{playlistId}

        Args:
            playlistId: The unique identifier of the playlist. This can be retrieved from the response of the list digital signage library playl

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/digital_signage/playlists/{playlistId}".format(playlistId=playlistId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_digital_signagelibraryplaylist" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_digital_signagelibraryplaylist")

    async def delete_digital_signagelibraryplaylist(
        self,
        playlistId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Delete Digital Signage library playlist

        HTTP DELETE /rooms/content/digital_signage/playlists/{playlistId}

        Args:
            playlistId: The unique identifier of the playlist. This can be retrieved from the response of the List Digital Signage library playl
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/digital_signage/playlists/{playlistId}".format(playlistId=playlistId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_digital_signagelibraryplaylist" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_digital_signagelibraryplaylist")

    async def updatea_digital_signagelibraryplaylist(
        self,
        playlistId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a Digital Signage library playlist

        HTTP PATCH /rooms/content/digital_signage/playlists/{playlistId}

        Args:
            playlistId: The unique identifier of the playlist. This can be retrieved from the response of the List Digital Signage library playl
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/digital_signage/playlists/{playlistId}".format(playlistId=playlistId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed updatea_digital_signagelibraryplaylist" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute updatea_digital_signagelibraryplaylist")

    async def get_digital_signagelibraryplaylistcontentitems(
        self,
        playlistId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get Digital Signage library playlist content items

        HTTP GET /rooms/content/digital_signage/playlists/{playlistId}/contents

        Args:
            playlistId: The unique identifier of the playlist. This can be retrieved from the response of the List Digital Signage library playl
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/rooms/content/digital_signage/playlists/{playlistId}/contents".format(playlistId=playlistId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_digital_signagelibraryplaylistcontentitems" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_digital_signagelibraryplaylistcontentitems")

    async def update_digital_signagelibraryplaylistcontentitems(
        self,
        playlistId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update Digital Signage library playlist content items

        HTTP PUT /rooms/content/digital_signage/playlists/{playlistId}/contents

        Args:
            playlistId: The unique identifier of the playlist. This can be retrieved from the response of the List Digital Signage library playl
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/digital_signage/playlists/{playlistId}/contents".format(playlistId=playlistId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_digital_signagelibraryplaylistcontentitems" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_digital_signagelibraryplaylistcontentitems")

    async def list_digital_signagelibraryplaylistpublishedrooms(
        self,
        playlistId: str
    ) -> ZoomResponse:
        """List Digital Signage library playlist published rooms

        HTTP GET /rooms/content/digital_signage/playlists/{playlistId}/rooms

        Args:
            playlistId: The unique identifier of the playlist. This can be retrieved from the response of the List Digital Signage library playl

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/digital_signage/playlists/{playlistId}/rooms".format(playlistId=playlistId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_digital_signagelibraryplaylistpublishedrooms" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_digital_signagelibraryplaylistpublishedrooms")

    async def update_digital_signagelibraryplaylistpublishedrooms(
        self,
        playlistId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update Digital Signage library playlist published rooms

        HTTP PUT /rooms/content/digital_signage/playlists/{playlistId}/rooms

        Args:
            playlistId: The unique identifier of the playlist. This can be retrieved from the response of the List Digital Signage library playl
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/content/digital_signage/playlists/{playlistId}/rooms".format(playlistId=playlistId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_digital_signagelibraryplaylistpublishedrooms" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_digital_signagelibraryplaylistpublishedrooms")

    async def add_zoom_rooms_background_image_library_content(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add Zoom Rooms background image library content

        HTTP POST /zrbackground/files

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/zrbackground/files"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_zoom_rooms_background_image_library_content" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_zoom_rooms_background_image_library_content")

    async def update_zoom_rooms_background_image_library_content(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update Zoom Rooms background image library content

        HTTP PUT /zrbackground/files

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/zrbackground/files"

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_zoom_rooms_background_image_library_content" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_zoom_rooms_background_image_library_content")

    async def adddigitalsignageimageorvideo(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a digital signage image or video

        HTTP POST /zrdigitalsignage/files

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/zrdigitalsignage/files"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed adddigitalsignageimageorvideo" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute adddigitalsignageimageorvideo")

    async def updateadigitalsignageimageorvideofile(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a Digital Signage image or video file

        HTTP PUT /zrdigitalsignage/files

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/zrdigitalsignage/files"

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed updateadigitalsignageimageorvideofile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute updateadigitalsignageimageorvideofile")

    async def delete_device_1(
        self,
        roomId: str,
        deviceId: str
    ) -> ZoomResponse:
        """Delete a Zoom Room user device

        HTTP DELETE /rooms/{roomId}/devices/{deviceId}

        Args:
            roomId: The Zoom Room ID.
            deviceId: The Mac or Windows device ID. The value of this field can be retrieved from the [**List Zoom Room devices**](/docs/api-r

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/{roomId}/devices/{deviceId}".format(roomId=roomId, deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_device_1" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_device_1")

    async def change_zoom_rooms_app_version(
        self,
        roomId: str,
        deviceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Change Zoom Rooms app version

        HTTP PUT /rooms/{roomId}/devices/{deviceId}/app_version

        Args:
            roomId: Unique Identifier of the Zoom Room.
            deviceId: Unique Identifier of the Mac or the Windows device. The value of this field can be retrieved from the [**List Zoom Room
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/{roomId}/devices/{deviceId}/app_version".format(roomId=roomId, deviceId=deviceId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed change_zoom_rooms_app_version" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute change_zoom_rooms_app_version")

    async def list_zr_locations(
        self,
        parent_location_id: str | None = None,
        type_: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List Zoom Room locations

        HTTP GET /rooms/locations

        Args:
            parent_location_id: A unique identifier of the parent location. For instance, if a Zoom Room is located in Floor 1 of Building A, the locati
            type_: Use this field to filter the response by the type of location. The value can be one of the following: `country`, `states
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if parent_location_id is not None:
            query_params['parent_location_id'] = parent_location_id
        if type_ is not None:
            query_params['type'] = type_
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/rooms/locations"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_zr_locations" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_zr_locations")

    async def add_azr_location(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a location

        HTTP POST /rooms/locations

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/locations"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_azr_location" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_azr_location")

    async def get_zr_location_structure(
        self
    ) -> ZoomResponse:
        """Get Zoom Room location structure

        HTTP GET /rooms/locations/structure

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/locations/structure"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_zr_location_structure" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_zr_location_structure")

    async def update_zoom_rooms_location_structure(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update Zoom Rooms location structure

        HTTP PUT /rooms/locations/structure

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/locations/structure"

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_zoom_rooms_location_structure" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_zoom_rooms_location_structure")

    async def get_zr_location_profile(
        self,
        locationId: str
    ) -> ZoomResponse:
        """Get Zoom Room location profile

        HTTP GET /rooms/locations/{locationId}

        Args:
            locationId: Unique identifier of the location type. This can be retrieved using the [**List Zoom Room locations**](https://developer

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/locations/{locationId}".format(locationId=locationId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_zr_location_profile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_zr_location_profile")

    async def delete_azr_location(
        self,
        locationId: str
    ) -> ZoomResponse:
        """Delete a location

        HTTP DELETE /rooms/locations/{locationId}

        Args:
            locationId: Unique identifier of the location type. This can be retrieved using the [**List Zoom Room locations**](https://developer

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/locations/{locationId}".format(locationId=locationId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_azr_location" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_azr_location")

    async def update_zr_location_profile(
        self,
        locationId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update Zoom Room location profile

        HTTP PATCH /rooms/locations/{locationId}

        Args:
            locationId: Unique Identifier of the location. This can be retrieved from the [**List Zoom Room locations**](https://developers.zoom
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/locations/{locationId}".format(locationId=locationId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_zr_location_profile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_zr_location_profile")

    async def change_parent_location(
        self,
        locationId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Change the assigned parent location

        HTTP PUT /rooms/locations/{locationId}/location

        Args:
            locationId: Path parameter
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/locations/{locationId}/location".format(locationId=locationId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed change_parent_location" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute change_parent_location")

    async def get_zr_location_settings(
        self,
        locationId: str,
        setting_type: str | None = None
    ) -> ZoomResponse:
        """Get location settings

        HTTP GET /rooms/locations/{locationId}/settings

        Args:
            locationId: Unique identifier of the location type. This can be retrieved using the [**List Zoom Room locations**](https://developer
            setting_type: The type of setting that you would like to retrieve.  `alert`: Alert settings of the Zoom Rooms located in a specific lo

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if setting_type is not None:
            query_params['setting_type'] = setting_type

        url = self.base_url + "/rooms/locations/{locationId}/settings".format(locationId=locationId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_zr_location_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_zr_location_settings")

    async def update_zr_location_settings(
        self,
        locationId: str,
        body: dict[str, Any],
        setting_type: str | None = None
    ) -> ZoomResponse:
        """Update location settings

        HTTP PATCH /rooms/locations/{locationId}/settings

        Args:
            locationId: Unique identifier of the location type. This can be retrieved using the [**List Zoom Room locations**](https://developer
            body: Request body payload
            setting_type: The type of setting that you would like to update.    `alert`: Alert settings of the Zoom Rooms located in a specific lo

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if setting_type is not None:
            query_params['setting_type'] = setting_type

        url = self.base_url + "/rooms/locations/{locationId}/settings".format(locationId=locationId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_zr_location_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_zr_location_settings")

    async def assign_tags_to_zoom_rooms_by_location_id(
        self,
        locationId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign Tags to Zoom Rooms By Location ID

        HTTP PATCH /rooms/locations/{locationId}/tags

        Args:
            locationId: The location ID where all Zoom Rooms under this location to be assigned with tags.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/locations/{locationId}/tags".format(locationId=locationId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assign_tags_to_zoom_rooms_by_location_id" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assign_tags_to_zoom_rooms_by_location_id")

    async def list_zoom_room_tags(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List all Zoom Room Tags

        HTTP GET /rooms/tags

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token is used to paginate through large result sets. A next page token will be returned whenever the set o

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/rooms/tags"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_zoom_room_tags" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_zoom_room_tags")

    async def create_zoom_room_tag(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a new Zoom Rooms Tag

        HTTP POST /rooms/tags

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/tags"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_zoom_room_tag" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_zoom_room_tag")

    async def delete_zoom_room_tag(
        self,
        tagId: str
    ) -> ZoomResponse:
        """Delete Tag

        HTTP DELETE /rooms/tags/{tagId}

        Args:
            tagId: The Zoom Room Tag ID to be deleted.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/tags/{tagId}".format(tagId=tagId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_zoom_room_tag" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_zoom_room_tag")

    async def edit_zoom_room_tag(
        self,
        tagId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Edit Tag

        HTTP PATCH /rooms/tags/{tagId}

        Args:
            tagId: The Zoom Room Tag ID to be edited.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/tags/{tagId}".format(tagId=tagId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed edit_zoom_room_tag" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute edit_zoom_room_tag")

    async def unassign_zoom_room_tag(
        self,
        roomId: str,
        tag_ids: str | None = None
    ) -> ZoomResponse:
        """Un-assign Tags from a Zoom Room

        HTTP DELETE /rooms/{roomId}/tags

        Args:
            roomId: Unique identifier of the Zoom Room. This can be retrieved from the response of the [**List Zoom Rooms**](/docs/api-refer
            tag_ids: The Tag ID(s) to un-assign from the Zoom Room.  Enter `all` to un-assign all tags from a Zoom Room.  Currently, only one

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if tag_ids is not None:
            query_params['tag_ids'] = tag_ids

        url = self.base_url + "/rooms/{roomId}/tags".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed unassign_zoom_room_tag" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute unassign_zoom_room_tag")

    async def assign_tags_to_a_zoom_room(
        self,
        roomId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign Tags to a Zoom Room

        HTTP PATCH /rooms/{roomId}/tags

        Args:
            roomId: The unique identifier of the Zoom Room. This can be retrieved from the response of the [**List Zoom Rooms**](/docs/api-r
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/rooms/{roomId}/tags".format(roomId=roomId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assign_tags_to_a_zoom_room" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assign_tags_to_a_zoom_room")

    async def group_scim2_list(
        self,
        startIndex: int | None = None,
        count: int | None = None,
        filter_: str | None = None
    ) -> ZoomResponse:
        """List groups

        HTTP GET /scim2/Groups

        Args:
            startIndex: The start index of the records to be returned.
            count: The number of records returned in a single API call.
            filter_: The type of query:  * `displayName eq {groupName}` — Provide the group's name to filter the response to a specific group

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if startIndex is not None:
            query_params['startIndex'] = str(startIndex)
        if count is not None:
            query_params['count'] = str(count)
        if filter_ is not None:
            query_params['filter'] = filter_

        url = self.base_url + "/scim2/Groups"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_scim2_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_scim2_list")

    async def group_scim2_create(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a group

        HTTP POST /scim2/Groups

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scim2/Groups"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_scim2_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_scim2_create")

    async def group_scim2_get(
        self,
        groupId: str
    ) -> ZoomResponse:
        """Get a group

        HTTP GET /scim2/Groups/{groupId}

        Args:
            groupId: The group's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scim2/Groups/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_scim2_get" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_scim2_get")

    async def group_scim2_delete(
        self,
        groupId: str
    ) -> ZoomResponse:
        """Delete a group

        HTTP DELETE /scim2/Groups/{groupId}

        Args:
            groupId: The group's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scim2/Groups/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_scim2_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_scim2_delete")

    async def group_scim2_update(
        self,
        groupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a group

        HTTP PATCH /scim2/Groups/{groupId}

        Args:
            groupId: The group's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scim2/Groups/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_scim2_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_scim2_update")

    async def user_scim2_list(
        self,
        startIndex: int | None = None,
        count: int | None = None,
        filter_: str | None = None
    ) -> ZoomResponse:
        """List users

        HTTP GET /scim2/Users

        Args:
            startIndex: The start index of records to be returned.
            count: The number of records returned in a single API call.
            filter_: The query type:  * `userName eq {userEmail}` — Provide the user's email address to filter the response to a specific use

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if startIndex is not None:
            query_params['startIndex'] = str(startIndex)
        if count is not None:
            query_params['count'] = str(count)
        if filter_ is not None:
            query_params['filter'] = filter_

        url = self.base_url + "/scim2/Users"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_scim2_list" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_scim2_list")

    async def user_scim2_create(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a user

        HTTP POST /scim2/Users

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scim2/Users"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_scim2_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_scim2_create")

    async def user_scim2_get(
        self,
        userId: str
    ) -> ZoomResponse:
        """Get a user

        HTTP GET /scim2/Users/{userId}

        Args:
            userId: The user's Zoom ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scim2/Users/{userId}".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_scim2_get" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_scim2_get")

    async def user_scim2_update(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a user

        HTTP PUT /scim2/Users/{userId}

        Args:
            userId: The user's Zoom ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scim2/Users/{userId}".format(userId=userId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_scim2_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_scim2_update")

    async def user_scim2_delete(
        self,
        userId: str
    ) -> ZoomResponse:
        """Delete a user

        HTTP DELETE /scim2/Users/{userId}

        Args:
            userId: The user's Zoom ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scim2/Users/{userId}".format(userId=userId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_scim2_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_scim2_delete")

    async def user_adscim2_deactivate(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Deactivate a user

        HTTP PATCH /scim2/Users/{userId}

        Args:
            userId: The user's Zoom ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scim2/Users/{userId}".format(userId=userId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_adscim2_deactivate" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_adscim2_deactivate")

    async def getroutingresponse(
        self,
        formId: str,
        responseId: str
    ) -> ZoomResponse:
        """get routing response

        HTTP GET /scheduler/routing/forms/{formId}/response/{responseId}

        Args:
            formId: The identifier of the routing form.
            responseId: The identifier of the response to a particular routing form.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scheduler/routing/forms/{formId}/response/{responseId}".format(formId=formId, responseId=responseId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getroutingresponse" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getroutingresponse")

    async def report_analytics(
        self,
        to: str | None = None,
        from_: str | None = None,
        time_zone: str | None = None,
        user_id: str | None = None
    ) -> ZoomResponse:
        """Report analytics

        HTTP GET /scheduler/analytics

        Args:
            to: The upper bound (exclusive) for an event's start time to filter by. Optional. The default is not to filter by start time
            from_: The lower bound (exclusive) for an event's end time from which to filter. Optional. The default is not to filter by end
            time_zone: The time zone in the response. The default is the time zone of the calendar. Optional.
            user_id: The specific user's web user ID. Default is "me". Use "all" to query for analytics with respect to all members under tha

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if to is not None:
            query_params['to'] = to
        if from_ is not None:
            query_params['from'] = from_
        if time_zone is not None:
            query_params['time_zone'] = time_zone
        if user_id is not None:
            query_params['user_id'] = user_id

        url = self.base_url + "/scheduler/analytics"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_analytics" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_analytics")

    async def list_availability(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        user_id: str | None = None
    ) -> ZoomResponse:
        """List availability

        HTTP GET /scheduler/availability

        Args:
            page_size: The maximum number of availability returned on one result page.
            next_page_token: The token that specifies which result page to return.
            user_id: The return of the specific user's availability.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if user_id is not None:
            query_params['user_id'] = user_id

        url = self.base_url + "/scheduler/availability"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_availability" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_availability")

    async def insert_availability(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Insert availability

        HTTP POST /scheduler/availability

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scheduler/availability"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed insert_availability" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute insert_availability")

    async def get_availability(
        self,
        availabilityId: str
    ) -> ZoomResponse:
        """Get availability

        HTTP GET /scheduler/availability/{availabilityId}

        Args:
            availabilityId: The UUID of the availability schedule.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scheduler/availability/{availabilityId}".format(availabilityId=availabilityId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_availability" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_availability")

    async def delete_availability(
        self,
        availabilityId: str
    ) -> ZoomResponse:
        """Delete availability

        HTTP DELETE /scheduler/availability/{availabilityId}

        Args:
            availabilityId: The UUID of the availability schedule.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scheduler/availability/{availabilityId}".format(availabilityId=availabilityId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_availability" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_availability")

    async def patch_availability(
        self,
        availabilityId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Patch availability

        HTTP PATCH /scheduler/availability/{availabilityId}

        Args:
            availabilityId: The UUID of the availability schedule.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scheduler/availability/{availabilityId}".format(availabilityId=availabilityId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed patch_availability" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute patch_availability")

    async def list_scheduled_events(
        self,
        *,
        to: str | None = None,
        from_: str | None = None,
        page_size: int | None = None,
        order_by: str | None = None,
        time_zone: str | None = None,
        next_page_token: str | None = None,
        show_deleted: bool | None = None,
        event_type: str | None = None,
        user_id: str | None = None,
        search: str | None = None
    ) -> ZoomResponse:
        """List scheduled events

        HTTP GET /scheduler/events

        Args:
            to: The upper bound (exclusive) for an event's start time from which to filter.
            from_: The lower bound (exclusive) for an event's end time from which to filter.
            page_size: The maximum number of events returned on one result page.
            order_by: This field indicates the start time or the time when the event has been updated.
            time_zone: The time zone in the response.
            next_page_token: The token that specifies which result page to return.
            show_deleted: Whether to include deleted events (with status equals `cancelled`) in the result.
            event_type: Whether to return the pending events.
            user_id: The return of the specific user's scheduled event. It's only for admin
            search: This field returns search results from meeting ID or summary.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if to is not None:
            query_params['to'] = to
        if from_ is not None:
            query_params['from'] = from_
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if order_by is not None:
            query_params['order_by'] = order_by
        if time_zone is not None:
            query_params['time_zone'] = time_zone
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if show_deleted is not None:
            query_params['show_deleted'] = str(show_deleted).lower()
        if event_type is not None:
            query_params['event_type'] = event_type
        if user_id is not None:
            query_params['user_id'] = user_id
        if search is not None:
            query_params['search'] = search

        url = self.base_url + "/scheduler/events"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_scheduled_events" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_scheduled_events")

    async def get_scheduled_events(
        self,
        eventId: str,
        user_id: str | None = None
    ) -> ZoomResponse:
        """Get scheduled events

        HTTP GET /scheduler/events/{eventId}

        Args:
            eventId: Path parameter
            user_id: This field indicates whether the admin handles certain users. It's only for admin.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if user_id is not None:
            query_params['user_id'] = user_id

        url = self.base_url + "/scheduler/events/{eventId}".format(eventId=eventId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_scheduled_events" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_scheduled_events")

    async def delete_scheduled_events(
        self,
        eventId: str,
        user_id: str | None = None
    ) -> ZoomResponse:
        """Delete scheduled events

        HTTP DELETE /scheduler/events/{eventId}

        Args:
            eventId: Path parameter
            user_id: This field indicates whether the admin handles certain users. It's only for admin.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if user_id is not None:
            query_params['user_id'] = user_id

        url = self.base_url + "/scheduler/events/{eventId}".format(eventId=eventId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_scheduled_events" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_scheduled_events")

    async def patch_scheduled_events(
        self,
        eventId: str,
        body: dict[str, Any],
        user_id: str | None = None
    ) -> ZoomResponse:
        """Patch scheduled events

        HTTP PATCH /scheduler/events/{eventId}

        Args:
            eventId: The opaque identifier of the scheduled event.
            body: Request body payload
            user_id: This field indicates whether the admin handles certain users. It's only for admin.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if user_id is not None:
            query_params['user_id'] = user_id

        url = self.base_url + "/scheduler/events/{eventId}".format(eventId=eventId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed patch_scheduled_events" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute patch_scheduled_events")

    async def get_scheduled_event_attendee(
        self,
        eventId: str,
        attendeeId: str
    ) -> ZoomResponse:
        """Get scheduled event attendee

        HTTP GET /scheduler/events/{eventId}/attendees/{attendeeId}

        Args:
            eventId: The ID of scheduled event.
            attendeeId: The ID of attendee to get scheduled event attendee information.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scheduler/events/{eventId}/attendees/{attendeeId}".format(eventId=eventId, attendeeId=attendeeId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_scheduled_event_attendee" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_scheduled_event_attendee")

    async def list_schedules(
        self,
        *,
        to: str | None = None,
        from_: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        show_deleted: bool | None = None,
        time_zone: str | None = None,
        user_id: str | None = None
    ) -> ZoomResponse:
        """List schedules

        HTTP GET /scheduler/schedules

        Args:
            to: The upper bound (exclusive) for a schedule's start time from which to filter.
            from_: The lower bound (exclusive) for a schedule's end time from which to filter.
            page_size: The maximum number of schedule results returned on a result page.
            next_page_token: The token that specifies which result page to return.
            show_deleted: Whether to include the deleted schedule (with status equals "cancelled") in the result.
            time_zone: The time zone in the response.
            user_id: The return of the specific user's schedules. Ths setting is only for admin.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if to is not None:
            query_params['to'] = to
        if from_ is not None:
            query_params['from'] = from_
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if show_deleted is not None:
            query_params['show_deleted'] = str(show_deleted).lower()
        if time_zone is not None:
            query_params['time_zone'] = time_zone
        if user_id is not None:
            query_params['user_id'] = user_id

        url = self.base_url + "/scheduler/schedules"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_schedules" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_schedules")

    async def insert_schedule(
        self,
        body: dict[str, Any],
        user_id: str | None = None
    ) -> ZoomResponse:
        """Insert schedules

        HTTP POST /scheduler/schedules

        Args:
            body: Request body payload
            user_id: This field indicates that the admin handles certain users. This setting is only for admin.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if user_id is not None:
            query_params['user_id'] = user_id

        url = self.base_url + "/scheduler/schedules"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed insert_schedule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute insert_schedule")

    async def get_schedule(
        self,
        scheduleId: str,
        user_id: str | None = None
    ) -> ZoomResponse:
        """Get schedules

        HTTP GET /scheduler/schedules/{scheduleId}

        Args:
            scheduleId: The schedule's unique identifier.
            user_id: This field indicates that admins handle certain users. This setting is only for admin.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if user_id is not None:
            query_params['user_id'] = user_id

        url = self.base_url + "/scheduler/schedules/{scheduleId}".format(scheduleId=scheduleId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_schedule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_schedule")

    async def delete_schedules(
        self,
        scheduleId: str,
        user_id: str | None = None
    ) -> ZoomResponse:
        """Delete schedules

        HTTP DELETE /scheduler/schedules/{scheduleId}

        Args:
            scheduleId: The unique identifier of the schedule.
            user_id: This field indicates that the admin handles certain users. This setting is only for admin.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if user_id is not None:
            query_params['user_id'] = user_id

        url = self.base_url + "/scheduler/schedules/{scheduleId}".format(scheduleId=scheduleId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_schedules" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_schedules")

    async def patch_schedule(
        self,
        scheduleId: str,
        body: dict[str, Any],
        user_id: str | None = None
    ) -> ZoomResponse:
        """Patch schedules

        HTTP PATCH /scheduler/schedules/{scheduleId}

        Args:
            scheduleId: The schedule's unique identifier.
            body: Request body payload
            user_id: This field indicates that the admin handles certain users. This setting is only for admin.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if user_id is not None:
            query_params['user_id'] = user_id

        url = self.base_url + "/scheduler/schedules/{scheduleId}".format(scheduleId=scheduleId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed patch_schedule" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute patch_schedule")

    async def single_use_link(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Single use link

        HTTP POST /scheduler/schedules/single_use_link

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scheduler/schedules/single_use_link"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed single_use_link" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute single_use_link")

    async def create_shares(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create shares

        HTTP POST /scheduler/shares

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scheduler/shares"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_shares" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_shares")

    async def get_user(
        self,
        userId: str
    ) -> ZoomResponse:
        """Get user

        HTTP GET /scheduler/users/{userId}

        Args:
            userId: Path parameter

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/scheduler/users/{userId}".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_user" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_user")

    async def get_channel_mention_group(
        self,
        channelId: str
    ) -> ZoomResponse:
        """List channel mention groups

        HTTP GET /chat/channels/{channelId}/mention_group

        Args:
            channelId: The channel ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}/mention_group".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_channel_mention_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_channel_mention_group")

    async def create_channel_mention_group(
        self,
        channelId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a channel mention group

        HTTP POST /chat/channels/{channelId}/mention_group

        Args:
            channelId: The channel ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}/mention_group".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_channel_mention_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_channel_mention_group")

    async def delete_a_channel_mention_group(
        self,
        channelId: str,
        mentionGroupId: str
    ) -> ZoomResponse:
        """Delete a channel mention group

        HTTP DELETE /chat/channels/{channelId}/mention_group/{mentionGroupId}

        Args:
            channelId: The channel ID.
            mentionGroupId: The mention group ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}/mention_group/{mentionGroupId}".format(channelId=channelId, mentionGroupId=mentionGroupId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_a_channel_mention_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_a_channel_mention_group")

    async def update_channel_mention_group(
        self,
        channelId: str,
        mentionGroupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a channel mention group information

        HTTP PATCH /chat/channels/{channelId}/mention_group/{mentionGroupId}

        Args:
            channelId: The channel ID.
            mentionGroupId: The mention group ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}/mention_group/{mentionGroupId}".format(channelId=channelId, mentionGroupId=mentionGroupId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_channel_mention_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_channel_mention_group")

    async def list_the_members_of_mention_group(
        self,
        channelId: str,
        mentionGroupId: str,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List the members of a mention group

        HTTP GET /chat/channels/{channelId}/mention_group/{mentionGroupId}/members

        Args:
            channelId: The channel ID.
            mentionGroupId: The mention group ID.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            page_size: The number of records returned with a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/chat/channels/{channelId}/mention_group/{mentionGroupId}/members".format(channelId=channelId, mentionGroupId=mentionGroupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_the_members_of_mention_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_the_members_of_mention_group")

    async def add_a_channel_members_to_mention_group(
        self,
        channelId: str,
        mentionGroupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add channel members to a mention group

        HTTP POST /chat/channels/{channelId}/mention_group/{mentionGroupId}/members

        Args:
            channelId: The channel ID.
            mentionGroupId: The mention group ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}/mention_group/{mentionGroupId}/members".format(channelId=channelId, mentionGroupId=mentionGroupId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_a_channel_members_to_mention_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_a_channel_members_to_mention_group")

    async def remove_channel_mention_group_members(
        self,
        channelId: str,
        mentionGroupId: str,
        identifiers: str | None = None
    ) -> ZoomResponse:
        """Remove channel mention group members

        HTTP DELETE /chat/channels/{channelId}/mention_group/{mentionGroupId}/members

        Args:
            channelId: The channel ID.
            mentionGroupId: The mention group ID.
            identifiers: The user ID or member ID of the member you want to remove from the mention group.  Use commas (,) to separate. And you c

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if identifiers is not None:
            query_params['identifiers'] = identifiers

        url = self.base_url + "/chat/channels/{channelId}/mention_group/{mentionGroupId}/members".format(channelId=channelId, mentionGroupId=mentionGroupId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed remove_channel_mention_group_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute remove_channel_mention_group_members")

    async def list_all_channel_activity_logs(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        activity_type: str | None = None,
        start_date: str | None = None,
        end_date: str | None = None,
        channel_id: str | None = None
    ) -> ZoomResponse:
        """List channel activity logs

        HTTP GET /chat/activities/channels

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            activity_type: The activity log type.
            start_date: The activity log start date.
            end_date: The activity log end date. End date must be with in three days.
            channel_id: The channel's unique identifier. If channel_id is absent, we'll return activities of all channels.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if activity_type is not None:
            query_params['activity_type'] = activity_type
        if start_date is not None:
            query_params['start_date'] = start_date
        if end_date is not None:
            query_params['end_date'] = end_date
        if channel_id is not None:
            query_params['channel_id'] = channel_id

        url = self.base_url + "/chat/activities/channels"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_all_channel_activity_logs" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_all_channel_activity_logs")

    async def perform_operations_on_channels(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Perform operations on channels

        HTTP PATCH /chat/channels/events

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/events"

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed perform_operations_on_channels" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute perform_operations_on_channels")

    async def get_user_level_channel(
        self,
        channelId: str
    ) -> ZoomResponse:
        """Get a channel

        HTTP GET /chat/channels/{channelId}

        Args:
            channelId: The channel's unique identifier.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_user_level_channel" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_user_level_channel")

    async def delete_user_level_channel(
        self,
        channelId: str
    ) -> ZoomResponse:
        """Delete a channel

        HTTP DELETE /chat/channels/{channelId}

        Args:
            channelId: Channel ID: the channel's unique identifier.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_user_level_channel" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_user_level_channel")

    async def update_user_level_channel(
        self,
        channelId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a channel

        HTTP PATCH /chat/channels/{channelId}

        Args:
            channelId: The channel ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_user_level_channel" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_user_level_channel")

    async def list_user_level_channel_members(
        self,
        channelId: str,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List channel members

        HTTP GET /chat/channels/{channelId}/members

        Args:
            channelId: The channel's unique identifier.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl
            page_size: The number of records returned with a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/chat/channels/{channelId}/members".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_user_level_channel_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_user_level_channel_members")

    async def invite_user_level_channel_members(
        self,
        channelId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Invite channel members

        HTTP POST /chat/channels/{channelId}/members

        Args:
            channelId: The channel's unique identifier.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}/members".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed invite_user_level_channel_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute invite_user_level_channel_members")

    async def batch_remove_channel_members(
        self,
        channelId: str,
        member_ids: str | None = None,
        user_ids: str | None = None
    ) -> ZoomResponse:
        """Batch remove members from a channel

        HTTP DELETE /chat/channels/{channelId}/members

        Args:
            channelId: The channel's unique identifier.
            member_ids: The member IDs. Use commas (,) to separate a supported maximum of 20 IDs.
            user_ids: Member or user IDs. Use commas (,) to separate a supported maximum of 20 IDs.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if member_ids is not None:
            query_params['member_ids'] = member_ids
        if user_ids is not None:
            query_params['user_ids'] = user_ids

        url = self.base_url + "/chat/channels/{channelId}/members".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed batch_remove_channel_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute batch_remove_channel_members")

    async def list_channel_members_groups(
        self,
        channelId: str
    ) -> ZoomResponse:
        """List channel members (Groups)

        HTTP GET /chat/channels/{channelId}/members/groups

        Args:
            channelId: The channel's unique identifier.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}/members/groups".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_channel_members_groups" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_channel_members_groups")

    async def invite_channel_members_groups(
        self,
        channelId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Invite channel members (Groups)

        HTTP POST /chat/channels/{channelId}/members/groups

        Args:
            channelId: The channel's unique identifier.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}/members/groups".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed invite_channel_members_groups" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute invite_channel_members_groups")

    async def remove_a_member_group(
        self,
        channelId: str,
        groupId: str
    ) -> ZoomResponse:
        """Remove a member (group)

        HTTP DELETE /chat/channels/{channelId}/members/groups/{groupId}

        Args:
            channelId: The unique identifier of the channel from where you would like to remove a member group.
            groupId: The member group ID to remove from the channel.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}/members/groups/{groupId}".format(channelId=channelId, groupId=groupId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed remove_a_member_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute remove_a_member_group")

    async def join_channel(
        self,
        channelId: str
    ) -> ZoomResponse:
        """Join a channel

        HTTP POST /chat/channels/{channelId}/members/me

        Args:
            channelId: The channel ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}/members/me".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed join_channel" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute join_channel")

    async def leave_channel(
        self,
        channelId: str
    ) -> ZoomResponse:
        """Leave a channel

        HTTP DELETE /chat/channels/{channelId}/members/me

        Args:
            channelId: The channel's unique identifier.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}/members/me".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed leave_channel" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute leave_channel")

    async def remove_a_user_level_channel_member(
        self,
        channelId: str,
        identifier: str
    ) -> ZoomResponse:
        """Remove a member

        HTTP DELETE /chat/channels/{channelId}/members/{identifier}

        Args:
            channelId: The unique identifier of the channel from where you would like to remove a member. This can be retrieved from the [**Lis
            identifier: The email address or user ID or member ID of the member whom you would like to be remove from the channel.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}/members/{identifier}".format(channelId=channelId, identifier=identifier)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed remove_a_user_level_channel_member" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute remove_a_user_level_channel_member")

    async def get_channels(
        self,
        userId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List user's channels

        HTTP GET /chat/users/{userId}/channels

        Args:
            userId: The user's unique identifier.
            page_size: The number of records returned from a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/chat/users/{userId}/channels".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_channels" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_channels")

    async def create_channel(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a channel

        HTTP POST /chat/users/{userId}/channels

        Args:
            userId: The user's unique identifier.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/users/{userId}/channels".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_channel" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_channel")

    async def batch_delete_channels_account_level(
        self,
        userId: str,
        channel_ids: str | None = None
    ) -> ZoomResponse:
        """Batch delete channels

        HTTP DELETE /chat/users/{userId}/channels

        Args:
            userId: The user ID of the channel owner.
            channel_ids: The channels' unique identifier. You can set up to 50 channel IDs.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if channel_ids is not None:
            query_params['channel_ids'] = channel_ids

        url = self.base_url + "/chat/users/{userId}/channels".format(userId=userId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed batch_delete_channels_account_level" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute batch_delete_channels_account_level")

    async def get_account_channels(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List account's public channels

        HTTP GET /chat/channels

        Args:
            page_size: The number of records returned per page in a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/chat/channels"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_account_channels" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_account_channels")

    async def search_channels(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Search user's or account's channels

        HTTP POST /chat/channels/search

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/search"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed search_channels" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute search_channels")

    async def list_channel_activity_logs(
        self,
        channelId: str,
        page_size: int | None = None,
        next_page_token: str | None = None,
        activity_type: str | None = None,
        start_date: str | None = None,
        end_date: str | None = None
    ) -> ZoomResponse:
        """List channel activity logs

        HTTP GET /chat/channels/{channelId}/activities

        Args:
            channelId: The channel's unique identifier.
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            activity_type: The activity log type.
            start_date: The activity log start date.
            end_date: The activity log end date.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if activity_type is not None:
            query_params['activity_type'] = activity_type
        if start_date is not None:
            query_params['start_date'] = start_date
        if end_date is not None:
            query_params['end_date'] = end_date

        url = self.base_url + "/chat/channels/{channelId}/activities".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_channel_activity_logs" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_channel_activity_logs")

    async def get_channel_retention(
        self,
        channelId: str
    ) -> ZoomResponse:
        """Get retention policy of a channel

        HTTP GET /chat/channels/{channelId}/retention

        Args:
            channelId: The channel's unique identifier. The channel type must be 1, 2, 3, or 5. The channel must not be archived.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}/retention".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_channel_retention" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_channel_retention")

    async def update_channel_retention(
        self,
        channelId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update retention policy of a channel

        HTTP PATCH /chat/channels/{channelId}/retention

        Args:
            channelId: The channel's unique identifier. The channel type must be 1, 2, 3 or 5. The channel must not be archived.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channels/{channelId}/retention".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_channel_retention" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_channel_retention")

    async def get_channel(
        self,
        channelId: str,
        userId: str
    ) -> ZoomResponse:
        """Get a channel

        HTTP GET /chat/users/{userId}/channels/{channelId}

        Args:
            channelId: The channel's unique identifier.
            userId: The unique identifier of the user who is the member of the channel.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/users/{userId}/channels/{channelId}".format(channelId=channelId, userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_channel" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_channel")

    async def delete_channel(
        self,
        channelId: str,
        userId: str
    ) -> ZoomResponse:
        """Delete a channel

        HTTP DELETE /chat/users/{userId}/channels/{channelId}

        Args:
            channelId: The channel's unique identifier.
            userId: The user ID of the channel owner.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/users/{userId}/channels/{channelId}".format(channelId=channelId, userId=userId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_channel" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_channel")

    async def update_channel(
        self,
        channelId: str,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a channel

        HTTP PATCH /chat/users/{userId}/channels/{channelId}

        Args:
            channelId: The channel ID.
            userId: The unique identifier of the Zoom user who is the administrator of the channel.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/users/{userId}/channels/{channelId}".format(channelId=channelId, userId=userId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_channel" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_channel")

    async def list_channel_administrators(
        self,
        userId: str,
        channelId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List channel administrators

        HTTP GET /chat/users/{userId}/channels/{channelId}/admins

        Args:
            userId: The user ID of member in the channel.
            channelId: The channel ID.
            page_size: The number of records returned with a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/chat/users/{userId}/channels/{channelId}/admins".format(userId=userId, channelId=channelId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_channel_administrators" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_channel_administrators")

    async def promote_channel_members_as_admin(
        self,
        userId: str,
        channelId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Promote channel members to administrators

        HTTP POST /chat/users/{userId}/channels/{channelId}/admins

        Args:
            userId: The user ID.
            channelId: The channel ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/users/{userId}/channels/{channelId}/admins".format(userId=userId, channelId=channelId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed promote_channel_members_as_admin" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute promote_channel_members_as_admin")

    async def batch_demote_channel_administrators(
        self,
        userId: str,
        channelId: str,
        admin_ids: str | None = None,
        user_ids: str | None = None
    ) -> ZoomResponse:
        """Batch demote channel administrators

        HTTP DELETE /chat/users/{userId}/channels/{channelId}/admins

        Args:
            userId: The user ID of the channel administrator.
            channelId: The channel ID.
            admin_ids: The member IDs with channel admin privileges. Use commas (,) to separate a maximum of 10 IDs in a call.
            user_ids: The member IDs or user IDs with channel admin privileges. Use commas (,) to separate a maximum of 10 IDs in a call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if admin_ids is not None:
            query_params['admin_ids'] = admin_ids
        if user_ids is not None:
            query_params['user_ids'] = user_ids

        url = self.base_url + "/chat/users/{userId}/channels/{channelId}/admins".format(userId=userId, channelId=channelId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed batch_demote_channel_administrators" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute batch_demote_channel_administrators")

    async def list_channel_members(
        self,
        channelId: str,
        userId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List channel members

        HTTP GET /chat/users/{userId}/channels/{channelId}/members

        Args:
            channelId: The channel ID.
            userId: The unique identifier of the user who is the owner of this channel.
            page_size: The number of records returned with a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/chat/users/{userId}/channels/{channelId}/members".format(channelId=channelId, userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_channel_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_channel_members")

    async def invite_channel_members(
        self,
        channelId: str,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Invite channel members

        HTTP POST /chat/users/{userId}/channels/{channelId}/members

        Args:
            channelId: The channel's unique identifier.
            userId: The unique identifier of the user who is the member of this channel.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/users/{userId}/channels/{channelId}/members".format(channelId=channelId, userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed invite_channel_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute invite_channel_members")

    async def batch_remove_user_channel_members(
        self,
        channelId: str,
        userId: str,
        identifiers: str | None = None
    ) -> ZoomResponse:
        """Batch remove members from a user's channel

        HTTP DELETE /chat/users/{userId}/channels/{channelId}/members

        Args:
            channelId: The channel ID.
            userId: The user ID of the channel owner or channel admin.
            identifiers: The user ID or member ID of the member you want to remove from the channel.  You can remove a maximum of 20 agent IDs.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if identifiers is not None:
            query_params['identifiers'] = identifiers

        url = self.base_url + "/chat/users/{userId}/channels/{channelId}/members".format(channelId=channelId, userId=userId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed batch_remove_user_channel_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute batch_remove_user_channel_members")

    async def remove_a_channel_member(
        self,
        channelId: str,
        identifier: str,
        userId: str
    ) -> ZoomResponse:
        """Remove a member

        HTTP DELETE /chat/users/{userId}/channels/{channelId}/members/{identifier}

        Args:
            channelId: The unique identifier of the channel from where you would like to remove a member. Retrieve this from the [**List user's
            identifier: The email address or user ID or member ID of the member whom you would like to be remove from the channel.
            userId: The unique identifier of the channel administrator.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/users/{userId}/channels/{channelId}/members/{identifier}".format(channelId=channelId, identifier=identifier, userId=userId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed remove_a_channel_member" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute remove_a_channel_member")

    async def list_custom_emojis(
        self,
        page_size: int | None = None,
        search_key: str | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List custom emojis

        HTTP GET /chat/emoji

        Args:
            page_size: The number of records returned with a single API call.
            search_key: The query string for emoji name. The minimum length is 3 characters. The maximum length is 256 characters. It is case se
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if search_key is not None:
            query_params['search_key'] = search_key
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/chat/emoji"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_custom_emojis" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_custom_emojis")

    async def add_a_custom_emoji(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a custom emoji

        HTTP POST /chat/emoji/files

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/emoji/files"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_a_custom_emoji" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_a_custom_emoji")

    async def delete_custom_emoji(
        self,
        fileId: str
    ) -> ZoomResponse:
        """Delete a custom emoji

        HTTP DELETE /chat/emoji/{fileId}

        Args:
            fileId: The unique ID of the file.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/emoji/{fileId}".format(fileId=fileId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_custom_emoji" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_custom_emoji")

    async def get_file_info(
        self,
        fileId: str
    ) -> ZoomResponse:
        """Get file info

        HTTP GET /chat/files/{fileId}

        Args:
            fileId: The chat file's unique ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/files/{fileId}".format(fileId=fileId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_file_info" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_file_info")

    async def delete_chat_file(
        self,
        fileId: str
    ) -> ZoomResponse:
        """Delete a chat file

        HTTP DELETE /chat/files/{fileId}

        Args:
            fileId: The chat file's unique ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/files/{fileId}".format(fileId=fileId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_chat_file" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_chat_file")

    async def upload_a_chat_file(
        self,
        userId: str,
        body: dict[str, Any],
        postToPersonalChat: str | None = None
    ) -> ZoomResponse:
        """Upload a chat file

        HTTP POST /chat/users/{userId}/files

        Args:
            userId: The user's ID.
            body: Request body payload
            postToPersonalChat: If this field is set to true, the file will be uploaded and posted to personal chat. Or if it is set to false, the file

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if postToPersonalChat is not None:
            query_params['postToPersonalChat'] = postToPersonalChat

        url = self.base_url + "/chat/users/{userId}/files".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed upload_a_chat_file" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute upload_a_chat_file")

    async def send_chat_file(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Send a chat file

        HTTP POST /chat/users/{userId}/messages/files

        Args:
            userId: The user's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/users/{userId}/messages/files".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed send_chat_file" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute send_chat_file")

    async def perform_message_of_channel(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Perform operations on the message of channel

        HTTP PATCH /chat/channel/message/events

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/channel/message/events"

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed perform_message_of_channel" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute perform_message_of_channel")

    async def list_channel_pinned_messages(
        self,
        channelId: str,
        *,
        page_size: int | None = None,
        next_page_token: str | None = None,
        include_history: bool | None = None
    ) -> ZoomResponse:
        """List pinned history messages of channel

        HTTP GET /chat/channels/{channelId}/pinned

        Args:
            channelId: The channel's unique identifier.
            page_size: The number of records returned with a single API call. The default value is 10.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            include_history: If the value is true, the query result includes pinned history messages.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if include_history is not None:
            query_params['include_history'] = str(include_history).lower()

        url = self.base_url + "/chat/channels/{channelId}/pinned".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_channel_pinned_messages" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_channel_pinned_messages")

    async def get_forwarded_message(
        self,
        forwardId: str
    ) -> ZoomResponse:
        """Get a forwarded message

        HTTP GET /chat/forwarded_message/{forwardId}

        Args:
            forwardId: The unique identifier of the forwarded message.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/forwarded_message/{forwardId}".format(forwardId=forwardId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_forwarded_message" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_forwarded_message")

    async def fetch_bookmarks(
        self,
        to_contact: str | None = None,
        to_channel: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List bookmarks

        HTTP GET /chat/messages/bookmarks

        Args:
            to_contact: This field allows you to query by the email address, user ID, or member ID of a chat contact. The API only returns messa
            to_channel: This field allows you to query by the channel ID of a channel in which the user had chat conversations. The API only ret
            page_size: The number of records to be returned with a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if to_contact is not None:
            query_params['to_contact'] = to_contact
        if to_channel is not None:
            query_params['to_channel'] = to_channel
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/chat/messages/bookmarks"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed fetch_bookmarks" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute fetch_bookmarks")

    async def add_or_remove_a_bookmark(
        self,
        body: dict[str, Any],
        message_id: str | None = None
    ) -> ZoomResponse:
        """Add or remove a bookmark

        HTTP PATCH /chat/messages/bookmarks

        Args:
            body: Request body payload
            message_id: The unique identifier of the message.  You can retrieve the message ID using the [**List user's chat messages**](https:/

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if message_id is not None:
            query_params['message_id'] = message_id

        url = self.base_url + "/chat/messages/bookmarks"

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_or_remove_a_bookmark" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_or_remove_a_bookmark")

    async def list_scheduled_messages(
        self,
        to_contact: str | None = None,
        to_channel: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List scheduled messages

        HTTP GET /chat/messages/schedule

        Args:
            to_contact: The email address, user ID, or member ID of the person to whom the draft message will be sent.
            to_channel: The channel ID to whom the draft message will be sent. You must provide this parameter or the `to_contact` parameter.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            page_size: The number of records returned with a single API call. The default value is 10.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if to_contact is not None:
            query_params['to_contact'] = to_contact
        if to_channel is not None:
            query_params['to_channel'] = to_channel
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/chat/messages/schedule"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_scheduled_messages" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_scheduled_messages")

    async def delete_schedule_message(
        self,
        draftId: str,
        to_contact: str | None = None,
        to_channel: str | None = None
    ) -> ZoomResponse:
        """Delete a scheduled message

        HTTP DELETE /chat/messages/schedule/{draftId}

        Args:
            draftId: The draft ID. Add this parameter if you want to delete a schedule message.
            to_contact: The email address, user ID, or member ID of the person to whom the draft message will be sent.
            to_channel: The channel ID where the draft message will be sent. You must provide this parameter or the `to_contact` parameter.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if to_contact is not None:
            query_params['to_contact'] = to_contact
        if to_channel is not None:
            query_params['to_channel'] = to_channel

        url = self.base_url + "/chat/messages/schedule/{draftId}".format(draftId=draftId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_schedule_message" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_schedule_message")

    async def get_chat_messages(
        self,
        userId: str,
        *,
        to_contact: str | None = None,
        to_channel: str | None = None,
        date: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        include_deleted_and_edited_message: bool | None = None,
        search_type: str | None = None,
        search_key: str | None = None,
        exclude_child_message: bool | None = None,
        download_file_formats: str | None = None
    ) -> ZoomResponse:
        """List user's chat messages

        HTTP GET /chat/users/{userId}/messages

        Args:
            userId: The unique identifier of the user.
            to_contact: This field allows you to query by the email address, user ID, or member ID of a chat contact with whom the user communic
            to_channel: This field allows you to query by the channel ID of a channel in which the user had chat conversations. The API only ret
            date: The query date from which to retrieve the chat messages. This value defaults to the current date.    **Note:** If you do
            from_: The query start date in `yyyy-MM-dd'T'HH:mm:ss'Z'` format.   **Note:** If you provide both the `date` and `from` query p
            to: The query end date in `yyyy-MM-dd'T'HH:mm:ss'Z'` format. This value defaults to the current date.
            page_size: The number of records returned with a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            include_deleted_and_edited_message: **Optional**      This field sets the value of this field to `true` to include edited and deleted messages in the respon
            search_type: The type of search:  * `message` &mdash; Search messages.  * `file` &mdash; Search files.   **Note:**  * If you use this
            search_key: The query string for messages or files, up to 256 characters.   **Note:**  * If you use this query parameter, you must a
            exclude_child_message: This parameter excludes returning all child messages in a chat. It leaves only the parent messages.
            download_file_formats: This field returns the download URL in the specified format for different types of files. Currently, we only support the

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if to_contact is not None:
            query_params['to_contact'] = to_contact
        if to_channel is not None:
            query_params['to_channel'] = to_channel
        if date is not None:
            query_params['date'] = date
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if include_deleted_and_edited_message is not None:
            query_params['include_deleted_and_edited_message'] = str(include_deleted_and_edited_message).lower()
        if search_type is not None:
            query_params['search_type'] = search_type
        if search_key is not None:
            query_params['search_key'] = search_key
        if exclude_child_message is not None:
            query_params['exclude_child_message'] = str(exclude_child_message).lower()
        if download_file_formats is not None:
            query_params['download_file_formats'] = download_file_formats

        url = self.base_url + "/chat/users/{userId}/messages".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_chat_messages" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_chat_messages")

    async def senda_chat_message(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Send a chat message

        HTTP POST /chat/users/{userId}/messages

        Args:
            userId: The unique identifier of the user.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/users/{userId}/messages".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed senda_chat_message" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute senda_chat_message")

    async def get_chat_message(
        self,
        userId: str,
        messageId: str,
        to_contact: str | None = None,
        to_channel: str | None = None,
        download_file_formats: str | None = None
    ) -> ZoomResponse:
        """Get a message

        HTTP GET /chat/users/{userId}/messages/{messageId}

        Args:
            userId: The unique identifier of the user.
            messageId: The unique identifier of the message.
            to_contact: The user ID, member ID, or email address of a chat contact to whom the message was sent. You must provide this parameter
            to_channel: The channel ID where the message was sent. You must provide this parameter or the `to_channel` parameter.
            download_file_formats: For different types of files, this field returns the download URL in the specified format.   Currently, we only support

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if to_contact is not None:
            query_params['to_contact'] = to_contact
        if to_channel is not None:
            query_params['to_channel'] = to_channel
        if download_file_formats is not None:
            query_params['download_file_formats'] = download_file_formats

        url = self.base_url + "/chat/users/{userId}/messages/{messageId}".format(userId=userId, messageId=messageId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_chat_message" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_chat_message")

    async def edit_message(
        self,
        userId: str,
        messageId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a message

        HTTP PUT /chat/users/{userId}/messages/{messageId}

        Args:
            userId: The unique identifier of the user.
            messageId: The unique identifier of the message.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/users/{userId}/messages/{messageId}".format(userId=userId, messageId=messageId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed edit_message" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute edit_message")

    async def delete_chat_message(
        self,
        userId: str,
        messageId: str,
        to_contact: str | None = None,
        to_channel: str | None = None
    ) -> ZoomResponse:
        """Delete a message

        HTTP DELETE /chat/users/{userId}/messages/{messageId}

        Args:
            userId: Unique identifier of the user.
            messageId: Message ID: Unique Identifier of the message.
            to_contact: The member ID  or user ID or email address of a chat contact to whom the message was sent. You must provide this paramet
            to_channel: The channel ID where the message was sent. You must provide this parameter or the `to_channel` parameter.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if to_contact is not None:
            query_params['to_contact'] = to_contact
        if to_channel is not None:
            query_params['to_channel'] = to_channel

        url = self.base_url + "/chat/users/{userId}/messages/{messageId}".format(userId=userId, messageId=messageId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_chat_message" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_chat_message")

    async def react_message(
        self,
        userId: str,
        messageId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """React to a chat message

        HTTP PATCH /chat/users/{userId}/messages/{messageId}/emoji_reactions

        Args:
            userId: The user's unique ID.
            messageId: The message's unique ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/users/{userId}/messages/{messageId}/emoji_reactions".format(userId=userId, messageId=messageId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed react_message" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute react_message")

    async def mark_message(
        self,
        userId: str,
        messageId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Mark message read or unread

        HTTP PATCH /chat/users/{userId}/messages/{messageId}/status

        Args:
            userId: The unique identifier of the user.
            messageId: The unique identifier of the message.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/users/{userId}/messages/{messageId}/status".format(userId=userId, messageId=messageId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed mark_message" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute mark_message")

    async def retrieve_thread(
        self,
        userId: str,
        messageId: str,
        *,
        to_channel: str | None = None,
        to_contact: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        limit: int | None = None,
        sort: str | None = None,
        need_main_message: bool | None = None,
        need_emoji: bool | None = None,
        need_attachment: bool | None = None,
        need_rich_text: bool | None = None,
        need_at_items: bool | None = None
    ) -> ZoomResponse:
        """Retrieve a thread

        HTTP GET /chat/users/{userId}/messages/{messageId}/thread

        Args:
            userId: The unique identifier of the user.
            messageId: The unique identifier of the main message to retrieve.
            to_channel: The channel ID where you want to query thread messages. You must provide this parameter or the `to_contact` parameter.
            to_contact: The user ID, member ID, or email address of a chat contact to whom the reminders you want to query. You must provide thi
            from_: The start time of the reply. The format is `yyyy-MM-dd'T'HH:mm:ss'Z'`.
            to: The end time of the reply. The format is `yyyy-MM-dd'T'HH:mm:ss'Z'`. If this value is not passed, it is the current time
            limit: This field limits the number of replies returned. The maximum value is 100.
            sort: This field can be designated as `desc` or `asc`, and is sorted by the reply time. If this parameter is `desc`, the lates
            need_main_message: Whether the main message is needed. This parameter controls whether the content of the main message is included in the r
            need_emoji: Whether the emoji is needed.
            need_attachment: Whether the attachments are needed.
            need_rich_text: Whether rich text is needed.
            need_at_items: Whether the @(at) items are needed.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if to_channel is not None:
            query_params['to_channel'] = to_channel
        if to_contact is not None:
            query_params['to_contact'] = to_contact
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if limit is not None:
            query_params['limit'] = str(limit)
        if sort is not None:
            query_params['sort'] = sort
        if need_main_message is not None:
            query_params['need_main_message'] = str(need_main_message).lower()
        if need_emoji is not None:
            query_params['need_emoji'] = str(need_emoji).lower()
        if need_attachment is not None:
            query_params['need_attachment'] = str(need_attachment).lower()
        if need_rich_text is not None:
            query_params['need_rich_text'] = str(need_rich_text).lower()
        if need_at_items is not None:
            query_params['need_at_items'] = str(need_at_items).lower()

        url = self.base_url + "/chat/users/{userId}/messages/{messageId}/thread".format(userId=userId, messageId=messageId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed retrieve_thread" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute retrieve_thread")

    async def migrate_channel_members(
        self,
        channelId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Migrate channel members

        HTTP POST /chat/migration/channels/{channelId}/members

        Args:
            channelId: The ID of the migrated channel.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/migration/channels/{channelId}/members".format(channelId=channelId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed migrate_channel_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute migrate_channel_members")

    async def migrate_chat_message_reactions(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Migrate chat message reactions

        HTTP POST /chat/migration/emoji_reactions

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/migration/emoji_reactions"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed migrate_chat_message_reactions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute migrate_chat_message_reactions")

    async def get_migration_channels_mapping(
        self,
        origin_platform: str | None = None,
        origin_team_id: str | None = None,
        origin_channel_ids: str | None = None
    ) -> ZoomResponse:
        """Get migrated Zoom channel IDs

        HTTP GET /chat/migration/mappings/channels

        Args:
            origin_platform: The chat platform that was migrated to Zoom. Right now, this API only accepts "slack".
            origin_team_id: The migrated team ID. If the origin platform is Slack, this is the unique ID of the Slack workspace.
            origin_channel_ids: The list of channel IDs migrated from the original platform. This cannot contain more than 20 IDs.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if origin_platform is not None:
            query_params['origin_platform'] = origin_platform
        if origin_team_id is not None:
            query_params['origin_team_id'] = origin_team_id
        if origin_channel_ids is not None:
            query_params['origin_channel_ids'] = origin_channel_ids

        url = self.base_url + "/chat/migration/mappings/channels"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_migration_channels_mapping" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_migration_channels_mapping")

    async def get_migration_users_mapping(
        self,
        origin_platform: str | None = None,
        origin_team_id: str | None = None,
        origin_user_ids: str | None = None
    ) -> ZoomResponse:
        """Get migrated Zoom user IDs

        HTTP GET /chat/migration/mappings/users

        Args:
            origin_platform: The chat platform that was migrated to Zoom. Right now, this API only accepts "slack".
            origin_team_id: The migrated team ID. If the origin platform is Slack, this is the unique ID of the Slack workspace.
            origin_user_ids: The list of user IDs migrated from the original platform. This cannot contain more than 20 IDs.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if origin_platform is not None:
            query_params['origin_platform'] = origin_platform
        if origin_team_id is not None:
            query_params['origin_team_id'] = origin_team_id
        if origin_user_ids is not None:
            query_params['origin_user_ids'] = origin_user_ids

        url = self.base_url + "/chat/migration/mappings/users"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_migration_users_mapping" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_migration_users_mapping")

    async def migrate_chat_messages(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Migrate chat messages

        HTTP POST /chat/migration/messages

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/migration/messages"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed migrate_chat_messages" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute migrate_chat_messages")

    async def migrate_a_chat_channel(
        self,
        identifier: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Migrate a chat channel

        HTTP POST /chat/migration/users/{identifier}/channels

        Args:
            identifier: The user ID or member ID of the owner of the chat channel being migrated.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/migration/users/{identifier}/channels".format(identifier=identifier)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed migrate_a_chat_channel" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute migrate_a_chat_channel")

    async def migrate1_1_conversation_or_channel_operations(
        self,
        identifier: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Migrate 1:1 conversation or channel operations

        HTTP POST /chat/migration/users/{identifier}/events

        Args:
            identifier: The user ID or member ID of the user who is a member of migrated 1:1 conversations or channels.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/migration/users/{identifier}/events".format(identifier=identifier)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed migrate1_1_conversation_or_channel_operations" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute migrate1_1_conversation_or_channel_operations")

    async def create_reminder_for_message(
        self,
        messageId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a reminder message

        HTTP POST /chat/messages/{messageId}/reminder

        Args:
            messageId: The unique identifier of the message.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/messages/{messageId}/reminder".format(messageId=messageId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_reminder_for_message" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_reminder_for_message")

    async def delete_reminder_for_message(
        self,
        messageId: str,
        to_contact: str | None = None,
        to_channel: str | None = None
    ) -> ZoomResponse:
        """Delete a reminder for a message

        HTTP DELETE /chat/messages/{messageId}/reminder

        Args:
            messageId: The unique identifier of the message.
            to_contact: The email address of the Zoom contact to whom you want to delete reminder.
            to_channel: The ID of the Zoom channel where you want to delete the reminder.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if to_contact is not None:
            query_params['to_contact'] = to_contact
        if to_channel is not None:
            query_params['to_channel'] = to_channel

        url = self.base_url + "/chat/messages/{messageId}/reminder".format(messageId=messageId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_reminder_for_message" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_reminder_for_message")

    async def list_reminders(
        self,
        to_contact: str | None = None,
        to_channel: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List reminders

        HTTP GET /chat/reminder

        Args:
            to_contact: The email address of the Zoom contact to whom you want to query reminders.   If neither `to_channel` nor `to_contact` is
            to_channel: The ID of the Zoom channel where you want to query reminders.   If neither `to_channel` nor `to_contact` is passed, all
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            page_size: The number of records returned per page in a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if to_contact is not None:
            query_params['to_contact'] = to_contact
        if to_channel is not None:
            query_params['to_channel'] = to_channel
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/chat/reminder"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_reminders" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_reminders")

    async def star_unstar_channel_contact(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Star or unstar a channel or contact user

        HTTP PATCH /chat/users/{userId}/events

        Args:
            userId: The user's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/users/{userId}/events".format(userId=userId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed star_unstar_channel_contact" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute star_unstar_channel_contact")

    async def get_chat_sessions(
        self,
        userId: str,
        *,
        type_: str | None = None,
        search_star: bool | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        from_: str | None = None,
        to: str | None = None
    ) -> ZoomResponse:
        """List a user's chat sessions

        HTTP GET /chat/users/{userId}/sessions

        Args:
            userId: The user ID of the sessions being queried.
            type_: The session queried by the chat type. The API only returns sessions of which the user is a member and of the specified c
            search_star: This field searches for starred groupchat and 1:1 chats.  **Note:**  * If `search_star` is provided, `type` parameter is
            page_size: The number of records returned with a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            from_: The query start date in `yyyy-MM-dd'T'HH:mm:ss'Z'` format. This value defaults to the start time of today.  **Note:**  *
            to: The query end date in `yyyy-MM-dd'T'HH:mm:ss'Z'` format. This value defaults to the end time of today.  **Note:**  * If

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if search_star is not None:
            query_params['search_star'] = str(search_star).lower()
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to

        url = self.base_url + "/chat/users/{userId}/sessions".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_chat_sessions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_chat_sessions")

    async def get_user_contacts(
        self,
        type_: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List user's contacts

        HTTP GET /chat/users/me/contacts

        Args:
            type_: The type of contact. The value can be one of the following: `company`: Contacts from the user's organization. `external`
            page_size: The number of records returned with a single API call.
            next_page_token: The next page token is used to paginate through large result sets. A next page token will be returned whenever the set o

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/chat/users/me/contacts"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_user_contacts" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_user_contacts")

    async def get_user_contact(
        self,
        identifier: str,
        *,
        query_presence_status: bool | None = None
    ) -> ZoomResponse:
        """Get user's contact details

        HTTP GET /chat/users/me/contacts/{identifier}

        Args:
            identifier: The contact's user ID, email address, or member ID. The contact can be either a company contact or an external contact.
            query_presence_status: The presence status of the contact.  Include this query parameter with a value of `true` to get the status of the contac

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if query_presence_status is not None:
            query_params['query_presence_status'] = str(query_presence_status).lower()

        url = self.base_url + "/chat/users/me/contacts/{identifier}".format(identifier=identifier)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_user_contact" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_user_contact")

    async def search_company_contacts(
        self,
        *,
        search_key: str | None = None,
        query_presence_status: bool | None = None,
        page_size: int | None = None,
        contact_types: int | None = None,
        user_status: str | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Search company contacts

        HTTP GET /contacts

        Args:
            search_key: Provide the keyword - either first name, last name or email of the contact whom you have to search for.
            query_presence_status: Set `query_presence_status` to `true` in order to include the presence status of a contact in the response.
            page_size: The number of records to be returned with a single API call.
            contact_types: A comma-separated list of the type of user contact to query:  * `1` &mdash; A Zoom user.  * `2` &mdash; An auto receptio
            user_status: The Zoom user's status:  * `active` &mdash; The user exists on the account.  * `inactive` &mdash; The user has been deac
            next_page_token: The next page token paginates through a large set of results. A next page token is returned whenever the set of availabl

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if search_key is not None:
            query_params['search_key'] = search_key
        if query_presence_status is not None:
            query_params['query_presence_status'] = str(query_presence_status).lower()
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if contact_types is not None:
            query_params['contact_types'] = str(contact_types)
        if user_status is not None:
            query_params['user_status'] = user_status
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/contacts"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed search_company_contacts" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute search_company_contacts")

    async def sendimmessages(
        self,
        body: dict[str, Any],
        chat_user: str | None = None
    ) -> ZoomResponse:
        """Send IM messages

        HTTP POST /im/users/me/chat/messages

        Args:
            body: Request body payload
            chat_user: The email address (registered with Zoom) or the userId of the chat user.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if chat_user is not None:
            query_params['chat_user'] = chat_user

        url = self.base_url + "/im/users/me/chat/messages"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed sendimmessages" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute sendimmessages")

    async def im_groups(
        self
    ) -> ZoomResponse:
        """List IM directory groups

        HTTP GET /im/groups

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/im/groups"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed im_groups" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute im_groups")

    async def im_group_create(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create an IM directory group

        HTTP POST /im/groups

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/im/groups"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed im_group_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute im_group_create")

    async def im_group(
        self,
        groupId: str
    ) -> ZoomResponse:
        """Retrieve an IM directory group

        HTTP GET /im/groups/{groupId}

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api-reference/zoom-api/methods#operation/groups) API.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/im/groups/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed im_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute im_group")

    async def im_group_delete(
        self,
        groupId: str
    ) -> ZoomResponse:
        """Delete an IM directory group

        HTTP DELETE /im/groups/{groupId}

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api-reference/zoom-api/methods#operation/groups) API.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/im/groups/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed im_group_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute im_group_delete")

    async def im_group_update(
        self,
        groupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update an IM directory group

        HTTP PATCH /im/groups/{groupId}

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api-reference/zoom-api/methods#operation/groups) API.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/im/groups/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed im_group_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute im_group_update")

    async def im_group_members(
        self,
        groupId: str,
        page_size: int | None = None,
        page_number: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List IM directory group members

        HTTP GET /im/groups/{groupId}/members

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api-reference/zoom-api/methods#operation/groups) API.
            page_size: The number of records returned within a single API call.
            page_number: **Deprecated.** We will no longer support this field in a future release. Instead, use the `next_page_token` for paginat
            next_page_token: The next page token paginates through large result sets. It whenever the set of available results exceeds the current pa

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if page_number is not None:
            query_params['page_number'] = str(page_number)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/im/groups/{groupId}/members".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed im_group_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute im_group_members")

    async def im_group_members_create(
        self,
        groupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add IM directory group members

        HTTP POST /im/groups/{groupId}/members

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api/rest/reference/user/methods/#operation/groups) API
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/im/groups/{groupId}/members".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed im_group_members_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute im_group_members_create")

    async def im_group_members_delete(
        self,
        groupId: str,
        memberId: str
    ) -> ZoomResponse:
        """Delete IM directory group member

        HTTP DELETE /im/groups/{groupId}/members/{memberId}

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api/rest/reference/user/methods/#operation/groups) API
            memberId: The member ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/im/groups/{groupId}/members/{memberId}".format(groupId=groupId, memberId=memberId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed im_group_members_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute im_group_members_delete")

    async def send_new_contact_invitation(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Send new contact invitation

        HTTP POST /chat/users/{userId}/invitations

        Args:
            userId: The unique identifier of the user who is the inviter.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/users/{userId}/invitations".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed send_new_contact_invitation" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute send_new_contact_invitation")

    async def list_legal_hold_matters(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List legal hold matters

        HTTP GET /chat/legalhold/matters

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/chat/legalhold/matters"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_legal_hold_matters" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_legal_hold_matters")

    async def add_legal_hold_matter(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add a legal hold matter

        HTTP POST /chat/legalhold/matters

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/legalhold/matters"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_legal_hold_matter" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_legal_hold_matter")

    async def delete_legal_hold_matters(
        self,
        matterId: str
    ) -> ZoomResponse:
        """Delete legal hold matters

        HTTP DELETE /chat/legalhold/matters/{matterId}

        Args:
            matterId: The legal hold matter's unique identifier.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/legalhold/matters/{matterId}".format(matterId=matterId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_legal_hold_matters" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_legal_hold_matters")

    async def update_legal_hold_matter(
        self,
        matterId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update legal hold matter

        HTTP PATCH /chat/legalhold/matters/{matterId}

        Args:
            matterId: The legal hold matter's unique identifier.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/legalhold/matters/{matterId}".format(matterId=matterId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_legal_hold_matter" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_legal_hold_matter")

    async def list_legal_hold_files(
        self,
        matterId: str,
        identifier: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List legal hold files by given matter

        HTTP GET /chat/legalhold/matters/{matterId}/files

        Args:
            matterId: The legal hold matter's unique identifier.
            identifier: The user's id or user's email to be legal check.
            page_size: The number of records to be returned with a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if identifier is not None:
            query_params['identifier'] = identifier
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/chat/legalhold/matters/{matterId}/files".format(matterId=matterId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_legal_hold_files" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_legal_hold_files")

    async def download_legal_hold_files(
        self,
        matterId: str,
        file_key: str | None = None
    ) -> ZoomResponse:
        """Download legal hold files for given matter

        HTTP GET /chat/legalhold/matters/{matterId}/files/download

        Args:
            matterId: The legal hold matter's unique identifier.
            file_key: This field download a zip file using the file key.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if file_key is not None:
            query_params['file_key'] = file_key

        url = self.base_url + "/chat/legalhold/matters/{matterId}/files/download".format(matterId=matterId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed download_legal_hold_files" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute download_legal_hold_files")

    async def report_chat_sessions(
        self,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """Get chat sessions reports

        HTTP GET /report/chat/sessions

        Args:
            from_: The start date in 'yyyy-mm-dd' format. The date range defined by the &quot;from&quot; and &quot;to&quot; parameters shou
            to: The end date.
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/report/chat/sessions"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_chat_sessions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_chat_sessions")

    async def report_chat_messages(
        self,
        sessionId: str,
        *,
        from_: str | None = None,
        to: str | None = None,
        next_page_token: str | None = None,
        page_size: int | None = None,
        include_fields: str | None = None,
        include_bot_message: bool | None = None,
        include_reactions: bool | None = None,
        query_all_modifications: bool | None = None
    ) -> ZoomResponse:
        """Get chat message reports

        HTTP GET /report/chat/sessions/{sessionId}

        Args:
            sessionId: The chat session's ID.
            from_: The start date in 'yyyy-mm-dd' format. The date range defined by the &quot;from&quot; and &quot;to&quot; parameters shou
            to: The end date.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            page_size: The number of records returned within a single API call.
            include_fields: This field returns all edited and deleted messages. The API only returns this value if the `include_fields` query parame
            include_bot_message: Whether to return the bot message. If false, the `bot_message` will not be returned in the response body.
            include_reactions: Whether to return the message reactions. If false, the `reactions` will not be returned in the response body.
            query_all_modifications: When set to true, this field allows users to query the time range in which edited or deleted messages were modified. Oth

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if include_fields is not None:
            query_params['include_fields'] = include_fields
        if include_bot_message is not None:
            query_params['include_bot_message'] = str(include_bot_message).lower()
        if include_reactions is not None:
            query_params['include_reactions'] = str(include_reactions).lower()
        if query_all_modifications is not None:
            query_params['query_all_modifications'] = str(query_all_modifications).lower()

        url = self.base_url + "/report/chat/sessions/{sessionId}".format(sessionId=sessionId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed report_chat_messages" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute report_chat_messages")

    async def list_shared_spaces(
        self,
        next_page_token: str | None = None,
        page_size: str | None = None,
        user_id: str | None = None
    ) -> ZoomResponse:
        """List shared spaces

        HTTP GET /chat/spaces

        Args:
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            page_size: The number of records returned with a single API call.
            user_id: The user ID or email address of the user.   For an `user-level app`, this API only returns shared spaces the caller is i

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = page_size
        if user_id is not None:
            query_params['user_id'] = user_id

        url = self.base_url + "/chat/spaces"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_shared_spaces" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_shared_spaces")

    async def create_space(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a shared space

        HTTP POST /chat/spaces

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/spaces"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_space" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_space")

    async def get_a_shared_space(
        self,
        spaceId: str
    ) -> ZoomResponse:
        """Get a shared space

        HTTP GET /chat/spaces/{spaceId}

        Args:
            spaceId: The space's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/spaces/{spaceId}".format(spaceId=spaceId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_a_shared_space" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_a_shared_space")

    async def delete_space(
        self,
        spaceId: str
    ) -> ZoomResponse:
        """Delete a shared space

        HTTP DELETE /chat/spaces/{spaceId}

        Args:
            spaceId: The shared space ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/spaces/{spaceId}".format(spaceId=spaceId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_space" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_space")

    async def update_shared_space_settings(
        self,
        spaceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update shared space settings

        HTTP PATCH /chat/spaces/{spaceId}

        Args:
            spaceId: The shared space's unique identifier ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/spaces/{spaceId}".format(spaceId=spaceId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_shared_space_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_shared_space_settings")

    async def promote_space_members(
        self,
        spaceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Promote shared space members to administrators

        HTTP POST /chat/spaces/{spaceId}/admins

        Args:
            spaceId: The shared space ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/spaces/{spaceId}/admins".format(spaceId=spaceId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed promote_space_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute promote_space_members")

    async def demote_space_admins(
        self,
        spaceId: str,
        identifiers: str | None = None
    ) -> ZoomResponse:
        """Demote shared space administrators to members

        HTTP DELETE /chat/spaces/{spaceId}/admins

        Args:
            spaceId: The shared space ID.
            identifiers: The user IDs or member IDs of the shared space administrators you want to demote to members, separated by comma (,).  Yo

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if identifiers is not None:
            query_params['identifiers'] = identifiers

        url = self.base_url + "/chat/spaces/{spaceId}/admins".format(spaceId=spaceId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed demote_space_admins" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute demote_space_admins")

    async def list_shared_space_channels(
        self,
        spaceId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List shared space channels

        HTTP GET /chat/spaces/{spaceId}/channels

        Args:
            spaceId: The space's ID
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token to paginates through large result sets. A next page token returns whenever the set of available resu

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/chat/spaces/{spaceId}/channels".format(spaceId=spaceId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_shared_space_channels" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_shared_space_channels")

    async def update_shared_space_channels(
        self,
        spaceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Move shared space channels

        HTTP PATCH /chat/spaces/{spaceId}/channels

        Args:
            spaceId: The shared space's unique identifier ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/spaces/{spaceId}/channels".format(spaceId=spaceId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_shared_space_channels" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_shared_space_channels")

    async def list_shared_space_members(
        self,
        spaceId: str,
        page_size: int | None = None,
        next_page_token: str | None = None,
        role: str | None = None,
        status: str | None = None
    ) -> ZoomResponse:
        """List shared space members

        HTTP GET /chat/spaces/{spaceId}/members

        Args:
            spaceId: The space's ID.
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results.  A next page token returns whenever the set of available r
            role: The user's role.  * `all` - All users in the shared space.  * `member` - Normal users in the shared space.  * `owner` -
            status: Whether to query active users or not. * `all` - All users in the shared space.  * `active` - Active users in the shared

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if role is not None:
            query_params['role'] = role
        if status is not None:
            query_params['status'] = status

        url = self.base_url + "/chat/spaces/{spaceId}/members".format(spaceId=spaceId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_shared_space_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_shared_space_members")

    async def add_space_members(
        self,
        spaceId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add members to a shared space

        HTTP POST /chat/spaces/{spaceId}/members

        Args:
            spaceId: The shared space ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/chat/spaces/{spaceId}/members".format(spaceId=spaceId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_space_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_space_members")

    async def delete_space_members(
        self,
        spaceId: str,
        identifiers: str | None = None
    ) -> ZoomResponse:
        """Remove members from a shared space

        HTTP DELETE /chat/spaces/{spaceId}/members

        Args:
            spaceId: The shared space ID.
            identifiers: The user ID or member ID of the shared space members or administrators you want to remove from the shared space.   You c

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if identifiers is not None:
            query_params['identifiers'] = identifiers

        url = self.base_url + "/chat/spaces/{spaceId}/members".format(spaceId=spaceId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_space_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_space_members")

    async def transfer_space_owner(
        self,
        spaceId: str,
        identifier: str | None = None
    ) -> ZoomResponse:
        """Transfer shared space ownership

        HTTP PATCH /chat/spaces/{spaceId}/owner

        Args:
            spaceId: The shared space ID.
            identifier: The user ID or member ID of the new shared space owner.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if identifier is not None:
            query_params['identifier'] = identifier

        url = self.base_url + "/chat/spaces/{spaceId}/owner".format(spaceId=spaceId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed transfer_space_owner" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute transfer_space_owner")

    async def contact_groups(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List contact groups

        HTTP GET /contacts/groups

        Args:
            page_size: The number of records returned with a single API call.
            next_page_token: The next page token is used to paginate through large result sets. A next page token will be returned whenever the set o

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/contacts/groups"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed contact_groups" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute contact_groups")

    async def contact_group_create(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a contact group

        HTTP POST /contacts/groups

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/contacts/groups"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed contact_group_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute contact_group_create")

    async def contact_group(
        self,
        groupId: str
    ) -> ZoomResponse:
        """Get a contact group

        HTTP GET /contacts/groups/{groupId}

        Args:
            groupId: The contact group ID.     Retrieve by calling the [**List contact groups**](/docs/api-reference/zoom-api/methods#operati

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/contacts/groups/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed contact_group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute contact_group")

    async def contact_group_delete(
        self,
        groupId: str
    ) -> ZoomResponse:
        """Delete a contact group

        HTTP DELETE /contacts/groups/{groupId}

        Args:
            groupId: The contact group ID.     Retrieve by calling the [**List contact groups**](/docs/api-reference/zoom-api/methods#operati

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/contacts/groups/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed contact_group_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute contact_group_delete")

    async def contact_group_update(
        self,
        groupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a contact group

        HTTP PATCH /contacts/groups/{groupId}

        Args:
            groupId: The contact group ID.     Retrieve by calling the [**List contact groups**](/docs/api-reference/zoom-api/methods#operati
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/contacts/groups/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed contact_group_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute contact_group_update")

    async def contact_group_members(
        self,
        groupId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List contact group members

        HTTP GET /contacts/groups/{groupId}/members

        Args:
            groupId: The group ID.
            page_size: The number of records returned with a single API call.
            next_page_token: The next page token is used to paginate through large result sets. A next page token will be returned whenever the set o

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/contacts/groups/{groupId}/members".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed contact_group_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute contact_group_members")

    async def contact_group_member_add(
        self,
        groupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add contact group members

        HTTP POST /contacts/groups/{groupId}/members

        Args:
            groupId: The contact group ID. Retrieve by calling the List contact groups API.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/contacts/groups/{groupId}/members".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed contact_group_member_add" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute contact_group_member_add")

    async def contact_group_member_remove(
        self,
        groupId: str,
        member_ids: str | None = None
    ) -> ZoomResponse:
        """Remove members in a contact group

        HTTP DELETE /contacts/groups/{groupId}/members

        Args:
            groupId: The contact group ID. Retrieve by calling the List contact groups API.
            member_ids: The member's ID in a contact group. Use commas (,) to separate a maximum of 20 ids.      Can be retrieved by calling the

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if member_ids is not None:
            query_params['member_ids'] = member_ids

        url = self.base_url + "/contacts/groups/{groupId}/members".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed contact_group_member_remove" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute contact_group_member_remove")

    async def list_divisions(
        self,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List divisions

        HTTP GET /divisions

        Args:
            next_page_token: Use the next page token to paginate through a large set of results. It returns whenever the set of available results exc
            page_size: The number of records returned within a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/divisions"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_divisions" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_divisions")

    async def createadivision(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a division

        HTTP POST /divisions

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/divisions"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed createadivision" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute createadivision")

    async def getdivision(
        self,
        divisionId: str
    ) -> ZoomResponse:
        """Get a division

        HTTP GET /divisions/{divisionId}

        Args:
            divisionId: The division's id

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/divisions/{divisionId}".format(divisionId=divisionId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getdivision" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getdivision")

    async def deletedivision(
        self,
        divisionId: str
    ) -> ZoomResponse:
        """Delete a division

        HTTP DELETE /divisions/{divisionId}

        Args:
            divisionId: The division's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/divisions/{divisionId}".format(divisionId=divisionId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed deletedivision" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute deletedivision")

    async def updateadivision(
        self,
        divisionId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a division

        HTTP PATCH /divisions/{divisionId}

        Args:
            divisionId: The division's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/divisions/{divisionId}".format(divisionId=divisionId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed updateadivision" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute updateadivision")

    async def list_division_members(
        self,
        divisionId: str,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List division members

        HTTP GET /divisions/{divisionId}/users

        Args:
            divisionId: The division's ID.
            next_page_token: Use the next page token to paginate through a large set of results. It returns whenever the set of available results exc
            page_size: The number of records returned within a single API call.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/divisions/{divisionId}/users".format(divisionId=divisionId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_division_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_division_members")

    async def assigndivision_member(
        self,
        divisionId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Assign a division

        HTTP POST /divisions/{divisionId}/users

        Args:
            divisionId: The division's ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/divisions/{divisionId}/users".format(divisionId=divisionId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed assigndivision_member" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute assigndivision_member")

    async def groups(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List groups

        HTTP GET /groups

        Args:
            page_size: The number of records returned in a single API call. The maximum is 300.
            next_page_token: The next page token paginates through a set of large results. A next page token is returned whenever the set of availabl

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/groups"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed groups" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute groups")

    async def group_create(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a group

        HTTP POST /groups

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/groups"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_create")

    async def group(
        self,
        groupId: str
    ) -> ZoomResponse:
        """Get a group

        HTTP GET /groups/{groupId}

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api-reference/zoom-api/methods#operation/groups) API.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/groups/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group")

    async def group_delete(
        self,
        groupId: str
    ) -> ZoomResponse:
        """Delete a group

        HTTP DELETE /groups/{groupId}

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api-reference/zoom-api/methods#operation/groups) API.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/groups/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_delete")

    async def group_update(
        self,
        groupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a group

        HTTP PATCH /groups/{groupId}

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api-reference/zoom-api/methods#operation/groups) API.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/groups/{groupId}".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_update")

    async def group_admins(
        self,
        groupId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List group admins

        HTTP GET /groups/{groupId}/admins

        Args:
            groupId: The group ID.   Retrieve by calling the [**List groups**](/docs/api-reference/zoom-api/methods#operation/groups) API.
            page_size: The number of records returned within a single API call.
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/groups/{groupId}/admins".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_admins" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_admins")

    async def group_admins_create(
        self,
        groupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add group admins

        HTTP POST /groups/{groupId}/admins

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api-reference/zoom-api/methods#operation/groups) API.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/groups/{groupId}/admins".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_admins_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_admins_create")

    async def group_admins_delete(
        self,
        groupId: str,
        userId: str
    ) -> ZoomResponse:
        """Delete a group admin

        HTTP DELETE /groups/{groupId}/admins/{userId}

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api-reference/zoom-api/methods#operation/groups) API.
            userId: The user ID or email address of the user. For user-level apps, pass the `me` value.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/groups/{groupId}/admins/{userId}".format(groupId=groupId, userId=userId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_admins_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_admins_delete")

    async def group_channels(
        self,
        groupId: str
    ) -> ZoomResponse:
        """List group channels

        HTTP GET /groups/{groupId}/channels

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api/rest/reference/user/methods/#operation/groups) API

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/groups/{groupId}/channels".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_channels" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_channels")

    async def get_group_lock_settings(
        self,
        groupId: str,
        option: str | None = None
    ) -> ZoomResponse:
        """Get locked settings

        HTTP GET /groups/{groupId}/lock_settings

        Args:
            groupId: The group's ID.
            option: Optional query parameters.  * `meeting_security` - Use this query parameter to view the meeting security settings applie

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if option is not None:
            query_params['option'] = option

        url = self.base_url + "/groups/{groupId}/lock_settings".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_group_lock_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_group_lock_settings")

    async def group_locked_settings(
        self,
        groupId: str,
        body: dict[str, Any],
        option: str | None = None
    ) -> ZoomResponse:
        """Update locked settings

        HTTP PATCH /groups/{groupId}/lock_settings

        Args:
            groupId: The group's ID.
            body: Request body payload
            option: Optional query parameters. * `meeting_security` - View the meeting security settings applied to the user's account.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if option is not None:
            query_params['option'] = option

        url = self.base_url + "/groups/{groupId}/lock_settings".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_locked_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_locked_settings")

    async def group_members(
        self,
        groupId: str,
        page_size: int | None = None,
        page_number: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List group members

        HTTP GET /groups/{groupId}/members

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api-reference/zoom-api/methods#operation/groups) API.
            page_size: The number of records returned within a single API call.
            page_number: **Deprecated.** We will no longer support this field in a future release. Instead, use the `next_page_token` for paginat
            next_page_token: Use the next page token to paginate through large result sets. A next page token is returned whenever the set of availab

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if page_number is not None:
            query_params['page_number'] = str(page_number)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/groups/{groupId}/members".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_members" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_members")

    async def group_members_create(
        self,
        groupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add group members

        HTTP POST /groups/{groupId}/members

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api-reference/zoom-api/methods#operation/groups) API.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/groups/{groupId}/members".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_members_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_members_create")

    async def group_members_delete(
        self,
        groupId: str,
        memberId: str
    ) -> ZoomResponse:
        """Delete a group member

        HTTP DELETE /groups/{groupId}/members/{memberId}

        Args:
            groupId: The group ID.     Retrieve by calling the [**List groups**](/docs/api-reference/zoom-api/methods#operation/groups) API.
            memberId: The member ID or email address.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/groups/{groupId}/members/{memberId}".format(groupId=groupId, memberId=memberId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_members_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_members_delete")

    async def update_a_group_member(
        self,
        groupId: str,
        memberId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a group member

        HTTP PATCH /groups/{groupId}/members/{memberId}

        Args:
            groupId: The group's unique ID. To get this value, use the [**List groups**](/docs/api-reference/zoom-api/methods#operation/group
            memberId: The group member's unique ID. To get this value, use the [**List group members**](/docs/api-reference/zoom-api/methods#o
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/groups/{groupId}/members/{memberId}".format(groupId=groupId, memberId=memberId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_a_group_member" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_a_group_member")

    async def get_group_settings(
        self,
        groupId: str,
        option: str | None = None,
        custom_query_fields: str | None = None
    ) -> ZoomResponse:
        """Get a group's settings

        HTTP GET /groups/{groupId}/settings

        Args:
            groupId: Path parameter
            option: Optional query parameters.  * `meeting_authentication` - View the [meeting authentication settings](https://support.zoom
            custom_query_fields: Provide the name of the field to use to filter the response. For example, if you provide `host_video` as the value of th

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if option is not None:
            query_params['option'] = option
        if custom_query_fields is not None:
            query_params['custom_query_fields'] = custom_query_fields

        url = self.base_url + "/groups/{groupId}/settings".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_group_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_group_settings")

    async def update_group_settings(
        self,
        groupId: str,
        body: dict[str, Any],
        option: str | None = None
    ) -> ZoomResponse:
        """Update a group's settings

        HTTP PATCH /groups/{groupId}/settings

        Args:
            groupId: The group's ID.
            body: Request body payload
            option: Optional query parameters.  * `meeting_authentication` - [Meeting authentication settings](https://support.zoom.us/hc/en

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if option is not None:
            query_params['option'] = option

        url = self.base_url + "/groups/{groupId}/settings".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_group_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_group_settings")

    async def group_settings_registration(
        self,
        groupId: str,
        type_: str | None = None
    ) -> ZoomResponse:
        """Get a group's webinar registration settings

        HTTP GET /groups/{groupId}/settings/registration

        Args:
            groupId: Path parameter
            type_: The registration type:  * `webinar` &mdash; webinar.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_

        url = self.base_url + "/groups/{groupId}/settings/registration".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_settings_registration" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_settings_registration")

    async def group_settings_registration_update(
        self,
        groupId: str,
        body: dict[str, Any],
        type_: str | None = None
    ) -> ZoomResponse:
        """Update a group's webinar registration settings

        HTTP PATCH /groups/{groupId}/settings/registration

        Args:
            groupId: The group ID. Retrieve by calling the List groups API.
            body: Request body payload
            type_: The registration type:  * `webinar` &mdash; webinar.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_

        url = self.base_url + "/groups/{groupId}/settings/registration".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed group_settings_registration_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute group_settings_registration_update")

    async def upload_group_vb(
        self,
        groupId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Upload Virtual Background files

        HTTP POST /groups/{groupId}/settings/virtual_backgrounds

        Args:
            groupId: The group ID. To get a group's ID, use the [**List groups**](/api-reference/zoom-api/methods#operation/groups) API.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/groups/{groupId}/settings/virtual_backgrounds".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed upload_group_vb" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute upload_group_vb")

    async def del_group_vb(
        self,
        groupId: str,
        file_ids: str | None = None
    ) -> ZoomResponse:
        """Delete Virtual Background files

        HTTP DELETE /groups/{groupId}/settings/virtual_backgrounds

        Args:
            groupId: The group ID. To get a group's ID, use the [**List groups**](/api-reference/zoom-api/methods#operation/groups) API.
            file_ids: A comma-separated list of the file IDs to delete.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if file_ids is not None:
            query_params['file_ids'] = file_ids

        url = self.base_url + "/groups/{groupId}/settings/virtual_backgrounds".format(groupId=groupId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed del_group_vb" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute del_group_vb")

    async def users(
        self,
        status: str | None = None,
        page_size: int | None = None,
        role_id: str | None = None,
        page_number: str | None = None,
        include_fields: str | None = None,
        next_page_token: str | None = None,
        license_: str | None = None
    ) -> ZoomResponse:
        """List users

        HTTP GET /users

        Args:
            status: The user's status.  * `active` - The user exists on the account.  * `inactive` - The user has been deactivated.  * `pend
            page_size: The number of records returned within a single API call.
            role_id: The role's unique ID. Use this parameter to filter the response by a specific role. You can use the [**List roles**](/do
            page_number: The page number of the current page in the returned records. We will no longer support this field in a future release. I
            include_fields: This parameter displays one of the following attributes in the API call's response:  * `custom_attributes` &mdash; Retur
            next_page_token: The next page token paginates through a large set of results. It returns whenever the set of available results exceeds t
            license_: The user's license. Filter the response by a specific license.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if status is not None:
            query_params['status'] = status
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if role_id is not None:
            query_params['role_id'] = role_id
        if page_number is not None:
            query_params['page_number'] = page_number
        if include_fields is not None:
            query_params['include_fields'] = include_fields
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if license_ is not None:
            query_params['license'] = license_

        url = self.base_url + "/users"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed users" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute users")

    async def user_create(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create users

        HTTP POST /users

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_create")

    async def user_email(
        self,
        email: str | None = None
    ) -> ZoomResponse:
        """Check a user email

        HTTP GET /users/email

        Args:
            email: The email address to be verified.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if email is not None:
            query_params['email'] = email

        url = self.base_url + "/users/email"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_email" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_email")

    async def bulk_update_feature(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Bulk update features for users

        HTTP POST /users/features

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/features"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed bulk_update_feature" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute bulk_update_feature")

    async def user_zak(
        self
    ) -> ZoomResponse:
        """Get the user's ZAK

        HTTP GET /users/me/zak

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/me/zak"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_zak" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_zak")

    async def user_summary(
        self
    ) -> ZoomResponse:
        """Get user summary

        HTTP GET /users/summary

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/summary"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_summary" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_summary")

    async def user_vanity_name(
        self,
        vanity_name: str | None = None
    ) -> ZoomResponse:
        """Check a user's PM room

        HTTP GET /users/vanity_name

        Args:
            vanity_name: Personal meeting room name.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if vanity_name is not None:
            query_params['vanity_name'] = vanity_name

        url = self.base_url + "/users/vanity_name"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_vanity_name" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_vanity_name")

    async def user(
        self,
        userId: str,
        *,
        login_type: int | None = None,
        encrypted_email: bool | None = None,
        search_by_unique_id: bool | None = None
    ) -> ZoomResponse:
        """Get a user

        HTTP GET /users/{userId}

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            login_type: The user's login method.  * `0` - Facebook OAuth  * `1` - Google OAuth.  * `24` - Apple OAuth.  * `27` - Microsoft OAuth
            encrypted_email: Whether the email address passed for the `userId` value is an encrypted email address.    * `true` - The email address i
            search_by_unique_id: Whether the queried `userId` value is an employee unique ID.  * `true` - The queried ID is an employee's unique ID.  * `

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if login_type is not None:
            query_params['login_type'] = str(login_type)
        if encrypted_email is not None:
            query_params['encrypted_email'] = str(encrypted_email).lower()
        if search_by_unique_id is not None:
            query_params['search_by_unique_id'] = str(search_by_unique_id).lower()

        url = self.base_url + "/users/{userId}".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user")

    async def user_delete(
        self,
        userId: str,
        *,
        encrypted_email: bool | None = None,
        action: str | None = None,
        transfer_email: str | None = None,
        transfer_meeting: bool | None = None,
        transfer_webinar: bool | None = None,
        transfer_recording: bool | None = None,
        transfer_whiteboard: bool | None = None,
        transfer_clipfiles: bool | None = None,
        transfer_notes: bool | None = None,
        transfer_visitors: bool | None = None,
        transfer_docs: bool | None = None
    ) -> ZoomResponse:
        """Delete a user

        HTTP DELETE /users/{userId}

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            encrypted_email: Whether the email address passed for the `userId` value is an encrypted email address.    * `true` - The email address i
            action: Delete action options.   `disassociate` - Disassociate a user.    `delete`-  Permanently delete a user.    Note: To dele
            transfer_email: Transfer email. This field is **required** if the user has Zoom Events/Sessions feature. After you delete or disassociat
            transfer_meeting: Transfer meeting.
            transfer_webinar: Transfer webinar.
            transfer_recording: Transfer recording.
            transfer_whiteboard: When deleting a user, whether to transfer all their [Zoom Whiteboard](https://support.zoom.us/hc/en-us/articles/44109168
            transfer_clipfiles: Transfer clip files.
            transfer_notes: Transfer notes.
            transfer_visitors: Transfer visitors.
            transfer_docs: Transfer docs.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if encrypted_email is not None:
            query_params['encrypted_email'] = str(encrypted_email).lower()
        if action is not None:
            query_params['action'] = action
        if transfer_email is not None:
            query_params['transfer_email'] = transfer_email
        if transfer_meeting is not None:
            query_params['transfer_meeting'] = str(transfer_meeting).lower()
        if transfer_webinar is not None:
            query_params['transfer_webinar'] = str(transfer_webinar).lower()
        if transfer_recording is not None:
            query_params['transfer_recording'] = str(transfer_recording).lower()
        if transfer_whiteboard is not None:
            query_params['transfer_whiteboard'] = str(transfer_whiteboard).lower()
        if transfer_clipfiles is not None:
            query_params['transfer_clipfiles'] = str(transfer_clipfiles).lower()
        if transfer_notes is not None:
            query_params['transfer_notes'] = str(transfer_notes).lower()
        if transfer_visitors is not None:
            query_params['transfer_visitors'] = str(transfer_visitors).lower()
        if transfer_docs is not None:
            query_params['transfer_docs'] = str(transfer_docs).lower()

        url = self.base_url + "/users/{userId}".format(userId=userId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_delete")

    async def user_update(
        self,
        userId: str,
        body: dict[str, Any],
        *,
        login_type: int | None = None,
        remove_tsp_credentials: bool | None = None
    ) -> ZoomResponse:
        """Update a user

        HTTP PATCH /users/{userId}

        Args:
            userId: The user ID or email address. For user-level apps, pass the `me` value.
            body: Request body payload
            login_type: The user's login method.  * `0` - Facebook OAuth.  * `1` - Google OAuth.  * `24` - Apple OAuth.  * `27` - Microsoft OAut
            remove_tsp_credentials: Whether to remove the user's TSP credentials.  * `true` - The queried ID is an employee's unique ID.  * `false` - The qu

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if login_type is not None:
            query_params['login_type'] = str(login_type)
        if remove_tsp_credentials is not None:
            query_params['remove_tsp_credentials'] = str(remove_tsp_credentials).lower()

        url = self.base_url + "/users/{userId}".format(userId=userId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_update")

    async def user_assistants(
        self,
        userId: str
    ) -> ZoomResponse:
        """List user assistants

        HTTP GET /users/{userId}/assistants

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/assistants".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_assistants" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_assistants")

    async def user_assistant_create(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Add assistants

        HTTP POST /users/{userId}/assistants

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/assistants".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_assistant_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_assistant_create")

    async def user_assistants_delete(
        self,
        userId: str
    ) -> ZoomResponse:
        """Delete user assistants

        HTTP DELETE /users/{userId}/assistants

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/assistants".format(userId=userId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_assistants_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_assistants_delete")

    async def user_assistant_delete(
        self,
        userId: str,
        assistantId: str
    ) -> ZoomResponse:
        """Delete a user assistant

        HTTP DELETE /users/{userId}/assistants/{assistantId}

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            assistantId: Assistant ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/assistants/{assistantId}".format(userId=userId, assistantId=assistantId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_assistant_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_assistant_delete")

    async def list_collaboration_devices(
        self,
        userId: str
    ) -> ZoomResponse:
        """List a user's collaboration devices

        HTTP GET /users/{userId}/collaboration_devices

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/collaboration_devices".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_collaboration_devices" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_collaboration_devices")

    async def get_collaboration_device(
        self,
        userId: str,
        collaborationDeviceId: str
    ) -> ZoomResponse:
        """Get collaboration device detail

        HTTP GET /users/{userId}/collaboration_devices/{collaborationDeviceId}

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            collaborationDeviceId: The collaboration device ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/collaboration_devices/{collaborationDeviceId}".format(userId=userId, collaborationDeviceId=collaborationDeviceId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_collaboration_device" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_collaboration_device")

    async def user_email_update(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a user's email

        HTTP PUT /users/{userId}/email

        Args:
            userId: The users's user ID or email address. For user-level apps, pass the `me` value.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/email".format(userId=userId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_email_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_email_update")

    async def getmeetingsummarytemplates(
        self,
        userId: str
    ) -> ZoomResponse:
        """Get meeting summary templates

        HTTP GET /users/{userId}/meeting_summary_templates

        Args:
            userId: current user's id

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/meeting_summary_templates".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getmeetingsummarytemplates" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getmeetingsummarytemplates")

    async def get_user_meeting_templates(
        self,
        userId: str,
        meetingTemplateId: str
    ) -> ZoomResponse:
        """Get meeting template detail

        HTTP GET /users/{userId}/meeting_templates/{meetingTemplateId}

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            meetingTemplateId: The meeting template ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/meeting_templates/{meetingTemplateId}".format(userId=userId, meetingTemplateId=meetingTemplateId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_user_meeting_templates" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_user_meeting_templates")

    async def user_password(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a user's password

        HTTP PUT /users/{userId}/password

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/password".format(userId=userId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_password" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_password")

    async def user_permission(
        self,
        userId: str
    ) -> ZoomResponse:
        """Get user permissions

        HTTP GET /users/{userId}/permissions

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/permissions".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_permission" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_permission")

    async def user_picture(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Upload a user's profile picture

        HTTP POST /users/{userId}/picture

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/picture".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_picture" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_picture")

    async def user_picture_delete(
        self,
        userId: str
    ) -> ZoomResponse:
        """Delete a user's profile picture

        HTTP DELETE /users/{userId}/picture

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/picture".format(userId=userId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_picture_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_picture_delete")

    async def get_user_presence_status(
        self,
        userId: str
    ) -> ZoomResponse:
        """Get a user presence status

        HTTP GET /users/{userId}/presence_status

        Args:
            userId: The user ID, email address, or member ID. The user can be either a company user or an external user.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/presence_status".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_user_presence_status" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_user_presence_status")

    async def update_presence_status(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update a user's presence status

        HTTP PUT /users/{userId}/presence_status

        Args:
            userId: The user ID or email address. For user-level apps, pass the `me` value.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/presence_status".format(userId=userId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_presence_status" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_presence_status")

    async def user_schedulers(
        self,
        userId: str
    ) -> ZoomResponse:
        """List user schedulers

        HTTP GET /users/{userId}/schedulers

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/schedulers".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_schedulers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_schedulers")

    async def user_schedulers_delete(
        self,
        userId: str
    ) -> ZoomResponse:
        """Delete user schedulers

        HTTP DELETE /users/{userId}/schedulers

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/schedulers".format(userId=userId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_schedulers_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_schedulers_delete")

    async def user_scheduler_delete(
        self,
        userId: str,
        schedulerId: str
    ) -> ZoomResponse:
        """Delete a scheduler

        HTTP DELETE /users/{userId}/schedulers/{schedulerId}

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            schedulerId: Scheduler's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/schedulers/{schedulerId}".format(userId=userId, schedulerId=schedulerId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_scheduler_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_scheduler_delete")

    async def user_settings(
        self,
        userId: str,
        login_type: int | None = None,
        option: str | None = None,
        custom_query_fields: str | None = None
    ) -> ZoomResponse:
        """Get user settings

        HTTP GET /users/{userId}/settings

        Args:
            userId: The user ID or email address of the user. For user-level apps, pass the `me` value.
            login_type: The user's login method.  * `0` - Facebook OAuth  * `1` - Google OAuth  * `24` - Apple OAuth  * `27` - Microsoft OAuth
            option: Optional query parameters.  * `meeting_authentication` - Use this query parameter to view the [meeting authentication se
            custom_query_fields: Provide the name of the field to filter the response. For example, if you provide `host_video` as the value of this fiel

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if login_type is not None:
            query_params['login_type'] = str(login_type)
        if option is not None:
            query_params['option'] = option
        if custom_query_fields is not None:
            query_params['custom_query_fields'] = custom_query_fields

        url = self.base_url + "/users/{userId}/settings".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_settings" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_settings")

    async def user_settings_update(
        self,
        userId: str,
        body: dict[str, Any],
        option: str | None = None
    ) -> ZoomResponse:
        """Update user settings

        HTTP PATCH /users/{userId}/settings

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            body: Request body payload
            option: The optional query parameters:  * `meeting_authentication` &mdash; Use this query parameter to view the [meeting authent

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if option is not None:
            query_params['option'] = option

        url = self.base_url + "/users/{userId}/settings".format(userId=userId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_settings_update" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_settings_update")

    async def upload_v_buser(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Upload Virtual Background files

        HTTP POST /users/{userId}/settings/virtual_backgrounds

        Args:
            userId: The user's ID. To get a user's ID, use the [**List users**](/api-reference/zoom-api/ma#operation/users) API. For user-le
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/settings/virtual_backgrounds".format(userId=userId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed upload_v_buser" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute upload_v_buser")

    async def del_user_vb(
        self,
        userId: str,
        file_ids: str | None = None
    ) -> ZoomResponse:
        """Delete Virtual Background files

        HTTP DELETE /users/{userId}/settings/virtual_backgrounds

        Args:
            userId: The user's ID. To get a user's ID, use the [**List users**](/docs/api-reference/zoom-api/ma#operation/users) API. For us
            file_ids: A comma-separated list of the Virtual Background file IDs to delete.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if file_ids is not None:
            query_params['file_ids'] = file_ids

        url = self.base_url + "/users/{userId}/settings/virtual_backgrounds".format(userId=userId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed del_user_vb" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute del_user_vb")

    async def user_status(
        self,
        userId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update user status

        HTTP PUT /users/{userId}/status

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/status".format(userId=userId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_status" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_status")

    async def user_token(
        self,
        userId: str,
        type_: str | None = None,
        ttl: int | None = None,
        meeting_id: str | None = None
    ) -> ZoomResponse:
        """Get a user's token

        HTTP GET /users/{userId}/token

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.
            type_: The user token type.  * `zak` - A Zoom Access Key (ZAK) is used to generate a URL to start meetings. See [Getting a Zoom
            ttl: The ZAK/onbehalf expiration time to live (TTL), in seconds. To update the user's ZAK/onbehalf TTL, use this field with t
            meeting_id: The meeting's ID, use this field with the `onbehalf` value for the `type` query parameter.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if type_ is not None:
            query_params['type'] = type_
        if ttl is not None:
            query_params['ttl'] = str(ttl)
        if meeting_id is not None:
            query_params['meeting_id'] = meeting_id

        url = self.base_url + "/users/{userId}/token".format(userId=userId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_token" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_token")

    async def user_sso_token_delete(
        self,
        userId: str
    ) -> ZoomResponse:
        """Revoke a user's SSO token

        HTTP DELETE /users/{userId}/token

        Args:
            userId: The user's user ID or email address. For user-level apps, pass the `me` value.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/users/{userId}/token".format(userId=userId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed user_sso_token_delete" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute user_sso_token_delete")

    async def createwhiteboardsarchivefiles(
        self,
        page_size: int | None = None,
        next_page_token: str | None = None,
        from_: str | None = None,
        to: str | None = None
    ) -> ZoomResponse:
        """List whiteboards sessions

        HTTP GET /whiteboards/sessions

        Args:
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            from_: The query session `start_time `date in` yyyy-MM-dd'T'HH:mm:ssZ` format. The `start_time` of a session in the result list
            to: The query session`end_time` date, in `yyyy-MM-dd'T'HH:mm:ssZ` format. The `end_time` of session in result list should be

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to

        url = self.base_url + "/whiteboards/sessions"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed createwhiteboardsarchivefiles" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute createwhiteboardsarchivefiles")

    async def downloadwhiteboardsactivityfile(
        self,
        path: str
    ) -> ZoomResponse:
        """Download Whiteboards activity file

        HTTP GET /whiteboards/sessions/activity/download/{path}

        Args:
            path: The file path.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/sessions/activity/download/{path}".format(path=path)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed downloadwhiteboardsactivityfile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute downloadwhiteboardsactivityfile")

    async def listwhiteboardsessionsarchivedfiles(
        self,
        seesionId: str,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List whiteboard sessions activities

        HTTP GET /whiteboards/sessions/{seesionId}

        Args:
            seesionId: The session unique ID.
            page_size: The number of records returned within a single API call.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/whiteboards/sessions/{seesionId}".format(seesionId=seesionId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed listwhiteboardsessionsarchivedfiles" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute listwhiteboardsessionsarchivedfiles")

    async def get_a_whiteboard_collaborator(
        self,
        whiteboardId: str
    ) -> ZoomResponse:
        """Get collaborators of a whiteboard

        HTTP GET /whiteboards/{whiteboardId}/collaborator

        Args:
            whiteboardId: The ID of the whiteboard.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/{whiteboardId}/collaborator".format(whiteboardId=whiteboardId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_a_whiteboard_collaborator" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_a_whiteboard_collaborator")

    async def add_a_whiteboard_collaborator(
        self,
        whiteboardId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Share a whiteboard to new users or team chat channels.

        HTTP POST /whiteboards/{whiteboardId}/collaborator

        Args:
            whiteboardId: The ID of the whiteboard.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/{whiteboardId}/collaborator".format(whiteboardId=whiteboardId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed add_a_whiteboard_collaborator" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute add_a_whiteboard_collaborator")

    async def update_a_whiteboard_collaborator(
        self,
        whiteboardId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update whiteboard collaborators

        HTTP PATCH /whiteboards/{whiteboardId}/collaborator

        Args:
            whiteboardId: The ID of the whiteboard.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/{whiteboardId}/collaborator".format(whiteboardId=whiteboardId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_a_whiteboard_collaborator" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_a_whiteboard_collaborator")

    async def delete_a_whiteboard_collaborator(
        self,
        whiteboardId: str,
        collaboratorId: str
    ) -> ZoomResponse:
        """Remove the collaborator from a whiteboard

        HTTP DELETE /whiteboards/{whiteboardId}/collaborator/{collaboratorId}

        Args:
            whiteboardId: The ID of the whiteboard.
            collaboratorId: The ID of the whiteboard collaborator.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/{whiteboardId}/collaborator/{collaboratorId}".format(whiteboardId=whiteboardId, collaboratorId=collaboratorId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_a_whiteboard_collaborator" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_a_whiteboard_collaborator")

    async def list_whiteboards(
        self,
        search_key: str | None = None,
        user_id: str | None = None,
        date_filter_type: str | None = None,
        from_: str | None = None,
        to: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None,
        project_id: str | None = None
    ) -> ZoomResponse:
        """List all whiteboards

        HTTP GET /whiteboards

        Args:
            search_key: The name of a whiteboard. If this parameter is provided, only the matched whiteboard will be returned. Otherwise, all wh
            user_id: The email address or user ID of the whiteboard owner. If this parameter is provided, only the whiteboard owned by the pr
            date_filter_type: The whiteboard date filter type.  Enum: * `created_date` - Whiteboard create date.  * `modified_date` - Whiteboard modif
            from_: The queried start date and time in `yyyy-MM-dd'T'HH:mm:ss'Z'` UTC format for the created date range for which you would
            to: The queried end date and time in `yyyy-MM-dd'T'HH:mm:ss'Z'` UTC format.
            page_size: The number of records returned from a single API call.
            next_page_token: The next page token is used to paginate through large result sets. A next page token will be returned whenever the set o
            project_id: Project ID to search for.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if search_key is not None:
            query_params['search_key'] = search_key
        if user_id is not None:
            query_params['user_id'] = user_id
        if date_filter_type is not None:
            query_params['date_filter_type'] = date_filter_type
        if from_ is not None:
            query_params['from'] = from_
        if to is not None:
            query_params['to'] = to
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if project_id is not None:
            query_params['project_id'] = project_id

        url = self.base_url + "/whiteboards"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_whiteboards" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_whiteboards")

    async def new_whiteboard_create(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a new whiteboard

        HTTP POST /whiteboards

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed new_whiteboard_create" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute new_whiteboard_create")

    async def get_a_whiteboard(
        self,
        whiteboardId: str
    ) -> ZoomResponse:
        """Get a whiteboard

        HTTP GET /whiteboards/{whiteboardId}

        Args:
            whiteboardId: The whiteboard's ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/{whiteboardId}".format(whiteboardId=whiteboardId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_a_whiteboard" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_a_whiteboard")

    async def update_a_whiteboard_metadata(
        self,
        whiteboardId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update whiteboard basic information

        HTTP PUT /whiteboards/{whiteboardId}

        Args:
            whiteboardId: The ID of the whiteboard.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/{whiteboardId}".format(whiteboardId=whiteboardId)

        try:
            request = HTTPRequest(
                method="PUT",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_a_whiteboard_metadata" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_a_whiteboard_metadata")

    async def delete_a_whiteboard(
        self,
        whiteboardId: str
    ) -> ZoomResponse:
        """Delete a whiteboard

        HTTP DELETE /whiteboards/{whiteboardId}

        Args:
            whiteboardId: The ID of the whiteboard.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/{whiteboardId}".format(whiteboardId=whiteboardId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_a_whiteboard" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_a_whiteboard")

    async def createwhiteboardsexport(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create whiteboard export

        HTTP POST /whiteboards/export

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/export"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed createwhiteboardsexport" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute createwhiteboardsexport")

    async def downloadwhiteboardexport(
        self,
        taskId: str
    ) -> ZoomResponse:
        """Download whiteboard export

        HTTP GET /whiteboards/export/task/{taskId}

        Args:
            taskId: The unique identifier of the whiteboards file. The `task_id` generated by [**Create whiteboard export**](https://develop

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/export/task/{taskId}".format(taskId=taskId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed downloadwhiteboardexport" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute downloadwhiteboardexport")

    async def getwhiteboardexportdatagenerationstatus(
        self,
        taskId: str
    ) -> ZoomResponse:
        """Get whiteboard export generation status

        HTTP GET /whiteboards/export/task/{taskId}/status

        Args:
            taskId: The unique identifier of the whiteboard export.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/export/task/{taskId}/status".format(taskId=taskId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getwhiteboardexportdatagenerationstatus" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getwhiteboardexportdatagenerationstatus")

    async def uploadfileforwhiteboardimport(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Upload file for whiteboard import

        HTTP POST /whiteboards/files

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/files"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed uploadfileforwhiteboardimport" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute uploadfileforwhiteboardimport")

    async def downloadembeddedwhiteboardfile(
        self,
        whiteboardId: str,
        fileId: str
    ) -> ZoomResponse:
        """Download Imported Whiteboard File

        HTTP GET /whiteboards/{whiteboardId}/files/{fileId}

        Args:
            whiteboardId: The whiteboard ID.
            fileId: The ID of the file imported into the whiteboard to download.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/{whiteboardId}/files/{fileId}".format(whiteboardId=whiteboardId, fileId=fileId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed downloadembeddedwhiteboardfile" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute downloadembeddedwhiteboardfile")

    async def create_whiteboard_import(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a new whiteboard by import

        HTTP POST /whiteboards/import

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/import"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_whiteboard_import" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_whiteboard_import")

    async def get_whiteboardimportstatus(
        self,
        taskId: str
    ) -> ZoomResponse:
        """Get whiteboard import status

        HTTP GET /whiteboards/import/{taskId}/status

        Args:
            taskId: The unique ID for your import.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/import/{taskId}/status".format(taskId=taskId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed get_whiteboardimportstatus" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute get_whiteboardimportstatus")

    async def listallprojects(
        self,
        search_key: str | None = None,
        user_id: str | None = None,
        page_size: int | None = None,
        next_page_token: str | None = None
    ) -> ZoomResponse:
        """List all projects

        HTTP GET /whiteboards/projects

        Args:
            search_key: The name of a project. If this parameter is provided, only the matched project will be returned. Otherwise, all projets
            user_id: The email address or user ID of the project owner. If this parameter is provided, only the project owned by the provided
            page_size: The number of records returned from a single API call.
            next_page_token: The next page token is used to paginate through large result sets. A next page token will be returned whenever the set o

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if search_key is not None:
            query_params['search_key'] = search_key
        if user_id is not None:
            query_params['user_id'] = user_id
        if page_size is not None:
            query_params['page_size'] = str(page_size)
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token

        url = self.base_url + "/whiteboards/projects"

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed listallprojects" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute listallprojects")

    async def createproject(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a new project

        HTTP POST /whiteboards/projects

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/projects"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed createproject" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute createproject")

    async def getaproject(
        self,
        projectId: str
    ) -> ZoomResponse:
        """Get a project

        HTTP GET /whiteboards/projects/{projectId}

        Args:
            projectId: The project ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/projects/{projectId}".format(projectId=projectId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getaproject" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getaproject")

    async def deleteproject(
        self,
        projectId: str
    ) -> ZoomResponse:
        """Delete a project

        HTTP DELETE /whiteboards/projects/{projectId}

        Args:
            projectId: The project ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/projects/{projectId}".format(projectId=projectId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed deleteproject" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute deleteproject")

    async def updateproject(
        self,
        projectId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update project basic information

        HTTP PATCH /whiteboards/projects/{projectId}

        Args:
            projectId: The project ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/projects/{projectId}".format(projectId=projectId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed updateproject" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute updateproject")

    async def getcollaboratorsofaproject(
        self,
        projectId: str
    ) -> ZoomResponse:
        """Get collaborators of a project

        HTTP GET /whiteboards/projects/{projectId}/collaborators

        Args:
            projectId: The ID of the project.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/projects/{projectId}/collaborators".format(projectId=projectId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getcollaboratorsofaproject" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getcollaboratorsofaproject")

    async def shareaprojecttonewusers(
        self,
        projectId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Share a project to new users

        HTTP POST /whiteboards/projects/{projectId}/collaborators

        Args:
            projectId: The project ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/projects/{projectId}/collaborators".format(projectId=projectId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed shareaprojecttonewusers" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute shareaprojecttonewusers")

    async def updateprojectcollaborators(
        self,
        projectId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update project collaborators

        HTTP PATCH /whiteboards/projects/{projectId}/collaborators

        Args:
            projectId: The project ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/projects/{projectId}/collaborators".format(projectId=projectId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed updateprojectcollaborators" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute updateprojectcollaborators")

    async def removethecollaboratorfromaproject(
        self,
        projectId: str,
        collaboratorId: str
    ) -> ZoomResponse:
        """Remove the collaborator from a project

        HTTP DELETE /whiteboards/projects/{projectId}/collaborators/{collaboratorId}

        Args:
            projectId: The project ID.
            collaboratorId: The collaborator ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/projects/{projectId}/collaborators/{collaboratorId}".format(projectId=projectId, collaboratorId=collaboratorId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed removethecollaboratorfromaproject" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute removethecollaboratorfromaproject")

    async def movewhiteboardstoproject(
        self,
        projectId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Move whiteboards to a project

        HTTP POST /whiteboards/projects/{projectId}/whiteboards

        Args:
            projectId: The Project ID
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/projects/{projectId}/whiteboards".format(projectId=projectId)

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed movewhiteboardstoproject" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute movewhiteboardstoproject")

    async def removewhiteboardsfromaproject(
        self,
        projectId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Remove whiteboards from a project

        HTTP DELETE /whiteboards/projects/{projectId}/whiteboards

        Args:
            projectId: The project ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/projects/{projectId}/whiteboards".format(projectId=projectId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed removewhiteboardsfromaproject" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute removewhiteboardsfromaproject")

    async def update_a_whiteboard_share_setting(
        self,
        whiteboardId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Update whiteboard share setting

        HTTP PATCH /whiteboards/{whiteboardId}/share_setting

        Args:
            whiteboardId: The ID of the whiteboard.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/whiteboards/{whiteboardId}/share_setting".format(whiteboardId=whiteboardId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed update_a_whiteboard_share_setting" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute update_a_whiteboard_share_setting")

    async def create_doc(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a new file

        HTTP POST /docs/files

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/docs/files"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed create_doc" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute create_doc")

    async def query_file_metadata(
        self,
        fileId: str
    ) -> ZoomResponse:
        """Get metadata of a file

        HTTP GET /docs/files/{fileId}

        Args:
            fileId: The doc file ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/docs/files/{fileId}".format(fileId=fileId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed query_file_metadata" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute query_file_metadata")

    async def delete_file(
        self,
        fileId: str
    ) -> ZoomResponse:
        """Delete a file

        HTTP DELETE /docs/files/{fileId}

        Args:
            fileId: The doc file ID.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/docs/files/{fileId}".format(fileId=fileId)

        try:
            request = HTTPRequest(
                method="DELETE",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed delete_file" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute delete_file")

    async def modify_metadata(
        self,
        fileId: str,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Modify metadata of a file

        HTTP PATCH /docs/files/{fileId}

        Args:
            fileId: The doc file ID.
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/docs/files/{fileId}".format(fileId=fileId)

        try:
            request = HTTPRequest(
                method="PATCH",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed modify_metadata" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute modify_metadata")

    async def list_all_children(
        self,
        fileId: str,
        next_page_token: str | None = None,
        page_size: int | None = None
    ) -> ZoomResponse:
        """List all children of a file

        HTTP GET /docs/files/{fileId}/children

        Args:
            fileId: The fileId of a file. When querying children of 'My docs', `fileId` should be `root`.
            next_page_token: The next page token paginates through a large set of results. A next page token returns whenever the set of available re
            page_size: The number of shared folders to query. The maximum size is 50.

        Returns:
            ZoomResponse with operation result
        """
        query_params: dict[str, Any] = {}
        if next_page_token is not None:
            query_params['next_page_token'] = next_page_token
        if page_size is not None:
            query_params['page_size'] = str(page_size)

        url = self.base_url + "/docs/files/{fileId}/children".format(fileId=fileId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
                query=query_params,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed list_all_children" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute list_all_children")

    async def uploadfilefordocsimportorattachments(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create file upload for docs import or attachments

        HTTP POST /docs/file_uploads

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/docs/file_uploads"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed uploadfilefordocsimportorattachments" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute uploadfilefordocsimportorattachments")

    async def createanewfilebyimport(
        self,
        body: dict[str, Any]
    ) -> ZoomResponse:
        """Create a new file by import

        HTTP POST /docs/imports

        Args:
            body: Request body payload

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/docs/imports"

        try:
            request = HTTPRequest(
                method="POST",
                url=url,
                headers={"Content-Type": "application/json"},
                body=body,
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed createanewfilebyimport" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute createanewfilebyimport")

    async def getdocsfileimportstatus(
        self,
        importId: str
    ) -> ZoomResponse:
        """Get file import status

        HTTP GET /docs/imports/{importId}/status

        Args:
            importId: The unique ID for your import.

        Returns:
            ZoomResponse with operation result
        """
        url = self.base_url + "/docs/imports/{importId}/status".format(importId=importId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message="Successfully executed getdocsfileimportstatus" if response.status < HTTP_ERROR_THRESHOLD else f"Failed with status {response.status}"
            )
        except Exception as e:
            return ZoomResponse(success=False, error=str(e), message="Failed to execute getdocsfileimportstatus")

    # -------------------------------------------------------------------------
    # Transcript helpers (connector-specific, not in the OpenAPI spec)
    # -------------------------------------------------------------------------

    async def meeting_transcript_metadata(self, meetingId: str) -> ZoomResponse:
        """Fetch AI Companion transcript metadata for a past meeting.

        HTTP GET /meetings/{meetingId}/transcript

        On success the response body contains a ``download_url`` that holds the
        actual transcript text.  On failure the body contains a Zoom error
        ``code`` (e.g. 3322 = no AI transcript, 3001/3301 = meeting not found).

        Args:
            meetingId: URL-encoded meeting UUID.

        Returns:
            ZoomResponse with ``data`` set to the parsed JSON body (or ``None``).
            ``success`` is False for any HTTP 4xx/5xx status.
        """
        url = self.base_url + "/meetings/{meetingId}/transcript".format(meetingId=meetingId)

        try:
            request = HTTPRequest(
                method="GET",
                url=url,
                headers={"Content-Type": "application/json"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            response_data = response.json() if response.text() else None
            return ZoomResponse(
                success=response.status < HTTP_ERROR_THRESHOLD,
                data=response_data,
                message=(
                    "Successfully fetched transcript metadata"
                    if response.status < HTTP_ERROR_THRESHOLD
                    else f"Failed with status {response.status}"
                ),
            )
        except Exception as e:
            return ZoomResponse(
                success=False,
                error=str(e),
                message="Failed to execute meeting_transcript_metadata",
            )

    async def meeting_transcript_download(self, download_url: str) -> ZoomResponse:
        """Download the transcript text from a pre-signed URL.

        The ``download_url`` is obtained from ``meeting_transcript_metadata``.
        The response body is plain text (VTT or similar format).

        Args:
            download_url: Fully-qualified URL returned by the transcript metadata call.

        Returns:
            ZoomResponse with ``data = {"transcript_text": "<content>"}`` on
            success, or ``success=False`` on any error.
        """
        try:
            request = HTTPRequest(
                method="GET",
                url=download_url,
                headers={"Accept": "text/plain"},
            )
            response = await self.http.execute(request)  # type: ignore[reportUnknownMemberType]
            if response.status >= HTTP_ERROR_THRESHOLD:
                return ZoomResponse(
                    success=False,
                    message=f"Transcript download failed with status {response.status}",
                )
            text = response.text()
            return ZoomResponse(
                success=True,
                data={"transcript_text": text or ""},
                message="Successfully downloaded transcript",
            )
        except Exception as e:
            return ZoomResponse(
                success=False,
                error=str(e),
                message="Failed to execute meeting_transcript_download",
            )
