universal-mcp-applications 0.1.22__py3-none-any.whl → 0.1.39rc8__py3-none-any.whl

universal_mcp/applications/calendly/app.py

@@ -1,5 +1,4 @@
 from typing import Any
-
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
@@ -9,9 +8,7 @@ class CalendlyApp(APIApplication):
         super().__init__(name="calendly", integration=integration, **kwargs)
         self.base_url = "https://api.calendly.com"
 
-    def list_event_invitees(
-        self, uuid, status=None, sort=None, email=None, page_token=None, count=None
-    ) -> dict[str, Any]:
+    async def list_event_invitees(self, uuid, status=None, sort=None, email=None, page_token=None, count=None) -> dict[str, Any]:
         """
         Retrieves a paginated list of invitees for a specific scheduled event, identified by its UUID. The results can be filtered by invitee status or email, sorted by creation date, and the list size can be controlled using pagination parameters.
 
@@ -34,20 +31,14 @@ class CalendlyApp(APIApplication):
         url = f"{self.base_url}/scheduled_events/{uuid}/invitees"
         query_params = {
             k: v
-            for k, v in [
-                ("status", status),
-                ("sort", sort),
-                ("email", email),
-                ("page_token", page_token),
-                ("count", count),
-            ]
+            for k, v in [("status", status), ("sort", sort), ("email", email), ("page_token", page_token), ("count", count)]
             if v is not None
         }
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_scheduled_event(self, uuid) -> dict[str, Any]:
+    async def get_scheduled_event(self, uuid) -> dict[str, Any]:
         """
         Retrieves the details for a specific scheduled event using its unique identifier (UUID). This targets a single event instance, differentiating it from `list_events` which fetches a collection of events and `get_event_type` which retrieves an event template.
 
@@ -64,11 +55,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'uuid'")
         url = f"{self.base_url}/scheduled_events/{uuid}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_event_invitee(self, event_uuid, invitee_uuid) -> dict[str, Any]:
+    async def get_event_invitee(self, event_uuid, invitee_uuid) -> dict[str, Any]:
         """
         Fetches detailed information for a single invitee associated with a specific scheduled event. It uses both the event's UUID and the invitee's UUID to uniquely identify and retrieve the correct record, distinguishing it from `list_event_invitees` which returns a collection.
 
@@ -88,11 +79,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'invitee_uuid'")
         url = f"{self.base_url}/scheduled_events/{event_uuid}/invitees/{invitee_uuid}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_scheduled_events(
+    async def list_scheduled_events(
         self,
         user=None,
         organization=None,
@@ -145,11 +136,11 @@ class CalendlyApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_event_type(self, uuid) -> dict[str, Any]:
+    async def get_event_type(self, uuid) -> dict[str, Any]:
         """
         Retrieves the full details of a specific event type, such as its name, duration, and scheduling rules, by providing its unique identifier (UUID). It fetches a single resource, unlike list_user_sevent_types which retrieves a collection.
 
@@ -166,11 +157,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'uuid'")
         url = f"{self.base_url}/event_types/{uuid}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_event_types(
+    async def list_event_types(
         self,
         active=None,
         organization=None,
@@ -215,11 +206,11 @@ class CalendlyApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_user(self, uuid) -> dict[str, Any]:
+    async def get_user(self, uuid) -> dict[str, Any]:
         """
         Retrieves the details of a specific user identified by their unique identifier (UUID). This differs from `get_current_user`, which fetches the profile of the currently authenticated user.
 
@@ -236,11 +227,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'uuid'")
         url = f"{self.base_url}/users/{uuid}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_current_user(self) -> dict[str, Any]:
+    async def get_current_user(self) -> dict[str, Any]:
         """
         Retrieves profile information for the currently authenticated user by querying the `/users/me` endpoint. This function requires no parameters, unlike `get_user` which fetches a specific user by their UUID.
 
@@ -252,13 +243,11 @@ class CalendlyApp(APIApplication):
         """
         url = f"{self.base_url}/users/me"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_organization_invitations(
-        self, uuid, count=None, page_token=None, sort=None, email=None, status=None
-    ) -> dict[str, Any]:
+    async def list_organization_invitations(self, uuid, count=None, page_token=None, sort=None, email=None, status=None) -> dict[str, Any]:
         """
         Retrieves a paginated list of invitations for a specific organization, identified by its UUID. It allows optional filtering by email and status (e.g., pending, accepted) and sorting. This function fetches a collection of invitations, unlike `get_organization_invitation` which retrieves a single one.
 
@@ -281,20 +270,14 @@ class CalendlyApp(APIApplication):
         url = f"{self.base_url}/organizations/{uuid}/invitations"
         query_params = {
             k: v
-            for k, v in [
-                ("count", count),
-                ("page_token", page_token),
-                ("sort", sort),
-                ("email", email),
-                ("status", status),
-            ]
+            for k, v in [("count", count), ("page_token", page_token), ("sort", sort), ("email", email), ("status", status)]
             if v is not None
         }
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def create_organization_invitation(self, uuid, email=None) -> dict[str, Any]:
+    async def create_organization_invitation(self, uuid, email=None) -> dict[str, Any]:
         """
         Invites a user via email to join a specific organization, identified by the organization's UUID. This function creates a new pending invitation, distinguishing it from functions that list, retrieve, or revoke existing invitations.
 
@@ -316,17 +299,15 @@ class CalendlyApp(APIApplication):
         """
         if uuid is None:
             raise ValueError("Missing required parameter 'uuid'")
-        request_body = {
-            "email": email,
-        }
+        request_body = {"email": email}
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/organizations/{uuid}/invitations"
         query_params = {}
-        response = self._post(url, data=request_body, params=query_params)
+        response = await self._apost(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_organization_invitation(self, org_uuid, uuid) -> dict[str, Any]:
+    async def get_organization_invitation(self, org_uuid, uuid) -> dict[str, Any]:
         """
         Retrieves the details of a single, specific invitation within an organization. It requires both the organization's unique identifier (`org_uuid`) and the invitation's unique identifier (`uuid`) for the lookup.
 
@@ -346,11 +327,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'uuid'")
         url = f"{self.base_url}/organizations/{org_uuid}/invitations/{uuid}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def revoke_user_organization_invitation(self, org_uuid, uuid) -> Any:
+    async def revoke_user_organization_invitation(self, org_uuid, uuid) -> Any:
         """
         Revokes a specific user's invitation to an organization, identified by the organization and invitation UUIDs. This action permanently deletes the pending invitation, preventing it from being accepted.
 
@@ -370,11 +351,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'uuid'")
         url = f"{self.base_url}/organizations/{org_uuid}/invitations/{uuid}"
         query_params = {}
-        response = self._delete(url, params=query_params)
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_organization_membership(self, uuid) -> dict[str, Any]:
+    async def get_organization_membership(self, uuid) -> dict[str, Any]:
         """
         Fetches the details of a specific organization membership using its unique identifier (UUID). Unlike `list_organization_memberships`, this function retrieves a single membership record rather than a collection.
 
@@ -391,11 +372,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'uuid'")
         url = f"{self.base_url}/organization_memberships/{uuid}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def delete_organization_membership(self, uuid) -> Any:
+    async def delete_organization_membership(self, uuid) -> Any:
         """
         Deletes an organization membership by its unique UUID, effectively removing the associated user from the organization. This function is the destructive counterpart to `get_organization_membership` and acts on active members, not pending invitations.
 
@@ -412,13 +393,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'uuid'")
         url = f"{self.base_url}/organization_memberships/{uuid}"
         query_params = {}
-        response = self._delete(url, params=query_params)
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_organization_memberships(
-        self, page_token=None, count=None, email=None, organization=None, user=None
-    ) -> dict[str, Any]:
+    async def list_organization_memberships(self, page_token=None, count=None, email=None, organization=None, user=None) -> dict[str, Any]:
         """
         Retrieves a paginated list of organization memberships. The results can be filtered by user, organization, or email address to narrow down the search for specific members within one or more organizations.
 
@@ -438,20 +417,14 @@ class CalendlyApp(APIApplication):
         url = f"{self.base_url}/organization_memberships"
         query_params = {
             k: v
-            for k, v in [
-                ("page_token", page_token),
-                ("count", count),
-                ("email", email),
-                ("organization", organization),
-                ("user", user),
-            ]
+            for k, v in [("page_token", page_token), ("count", count), ("email", email), ("organization", organization), ("user", user)]
             if v is not None
         }
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_webhook_subscription(self, webhook_uuid) -> dict[str, Any]:
+    async def get_webhook_subscription(self, webhook_uuid) -> dict[str, Any]:
         """
         Fetches detailed information for a single webhook subscription using its unique identifier (UUID). Unlike `list_webhook_subscriptions`, which returns a collection, this function retrieves one specific subscription's configuration and status.
 
@@ -468,11 +441,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'webhook_uuid'")
         url = f"{self.base_url}/webhook_subscriptions/{webhook_uuid}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def delete_webhook_subscription(self, webhook_uuid) -> Any:
+    async def delete_webhook_subscription(self, webhook_uuid) -> Any:
         """
         Deletes a specific webhook subscription using its unique `webhook_uuid`. This function sends a DELETE request to the Calendly API to permanently remove the subscription, stopping all future event notifications. It raises an error if the deletion fails.
 
@@ -489,18 +462,12 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'webhook_uuid'")
         url = f"{self.base_url}/webhook_subscriptions/{webhook_uuid}"
         query_params = {}
-        response = self._delete(url, params=query_params)
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_webhook_subscriptions(
-        self,
-        organization=None,
-        user=None,
-        page_token=None,
-        count=None,
-        sort=None,
-        scope=None,
+    async def list_webhook_subscriptions(
+        self, organization=None, user=None, page_token=None, count=None, sort=None, scope=None
     ) -> dict[str, Any]:
         """
         Retrieves a collection of webhook subscriptions for a given scope (organization or user). Supports filtering, sorting, and pagination to browse multiple subscriptions, unlike functions like `get_webhook_subscription` which fetches a single subscription by its unique ID.
@@ -534,19 +501,12 @@ class CalendlyApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def create_webhook_subscription(
-        self,
-        events=None,
-        group=None,
-        organization=None,
-        scope=None,
-        signing_key=None,
-        url=None,
-        user=None,
+    async def create_webhook_subscription(
+        self, events=None, group=None, organization=None, scope=None, signing_key=None, url=None, user=None
     ) -> dict[str, Any]:
         """
         Creates a Calendly webhook subscription for specified events. It requires a callback URL, the scope (e.g., organization, user), and the list of events to monitor, registering the webhook via a POST request to the API.
@@ -593,13 +553,11 @@ class CalendlyApp(APIApplication):
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/webhook_subscriptions"
         query_params = {}
-        response = self._post(url, data=request_body, params=query_params)
+        response = await self._apost(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def create_limited_use_scheduling_link(
-        self, max_event_count=None, owner=None, owner_type=None
-    ) -> dict[str, Any]:
+    async def create_limited_use_scheduling_link(self, max_event_count=None, owner=None, owner_type=None) -> dict[str, Any]:
         """
         Generates a unique, limited-use scheduling link for a specific owner, such as an event type. The link is valid for a specified maximum number of bookings, after which it expires.
 
@@ -622,19 +580,15 @@ class CalendlyApp(APIApplication):
         Tags:
             scheduling_links
         """
-        request_body = {
-            "max_event_count": max_event_count,
-            "owner": owner,
-            "owner_type": owner_type,
-        }
+        request_body = {"max_event_count": max_event_count, "owner": owner, "owner_type": owner_type}
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/scheduling_links"
         query_params = {}
-        response = self._post(url, data=request_body, params=query_params)
+        response = await self._apost(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def request_invitee_data_deletion(self, emails=None) -> dict[str, Any]:
+    async def request_invitee_data_deletion(self, emails=None) -> dict[str, Any]:
         """
         Submits an asynchronous data deletion request for one or more invitees, identified by their email addresses, to comply with privacy regulations. This action permanently removes invitee information from the system.
 
@@ -656,19 +610,15 @@ class CalendlyApp(APIApplication):
         Tags:
             data_compliance, deletion, invitees12
         """
-        request_body = {
-            "emails": emails,
-        }
+        request_body = {"emails": emails}
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/data_compliance/deletion/invitees"
         query_params = {}
-        response = self._post(url, data=request_body, params=query_params)
+        response = await self._apost(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def request_scheduled_event_data_deletion(
-        self, end_time=None, start_time=None
-    ) -> dict[str, Any]:
+    async def request_scheduled_event_data_deletion(self, end_time=None, start_time=None) -> dict[str, Any]:
         """
         For data compliance, submits an asynchronous request to delete scheduled event data within a specified `start_time` and `end_time`. This targets events by time range, unlike `delete_invitee_data` which targets specific individuals.
 
@@ -689,18 +639,15 @@ class CalendlyApp(APIApplication):
         Tags:
             data_compliance, deletion, events
         """
-        request_body = {
-            "end_time": end_time,
-            "start_time": start_time,
-        }
+        request_body = {"end_time": end_time, "start_time": start_time}
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/data_compliance/deletion/events"
         query_params = {}
-        response = self._post(url, data=request_body, params=query_params)
+        response = await self._apost(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_invitee_no_show(self, uuid) -> dict[str, Any]:
+    async def get_invitee_no_show(self, uuid) -> dict[str, Any]:
         """
         Retrieves the details for a specific 'no-show' record associated with an invitee, identified by its unique ID (UUID). This function fetches a single record, unlike create_invitee_no_show which creates one.
 
@@ -717,11 +664,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'uuid'")
         url = f"{self.base_url}/invitee_no_shows/{uuid}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def revoke_invitee_no_show(self, uuid) -> Any:
+    async def revoke_invitee_no_show(self, uuid) -> Any:
         """
         Deletes an invitee's 'no-show' record using its unique UUID. This operation revokes the no-show status previously assigned to an invitee, effectively undoing the action of `create_invitee_no_show`.
 
@@ -738,11 +685,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'uuid'")
         url = f"{self.base_url}/invitee_no_shows/{uuid}"
         query_params = {}
-        response = self._delete(url, params=query_params)
+        response = await self._adelete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def mark_invitee_as_no_show(self, invitee=None) -> dict[str, Any]:
+    async def mark_invitee_as_no_show(self, invitee=None) -> dict[str, Any]:
         """
         Marks a specific invitee as a 'no-show' by creating a no-show record. It requires the invitee's URI and sends a POST request to the `/invitee_no_shows` endpoint, returning the details of the newly created entry.
 
@@ -761,17 +708,15 @@ class CalendlyApp(APIApplication):
         Tags:
             invitee_no_shows
         """
-        request_body = {
-            "invitee": invitee,
-        }
+        request_body = {"invitee": invitee}
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/invitee_no_shows"
         query_params = {}
-        response = self._post(url, data=request_body, params=query_params)
+        response = await self._apost(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_group_by_id(self, uuid) -> dict[str, Any]:
+    async def get_group_by_id(self, uuid) -> dict[str, Any]:
         """
         Retrieves the details of a specific group by its unique identifier (UUID). Unlike `list_groups`, which returns multiple group records, this function fetches information for a single group.
 
@@ -788,13 +733,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'uuid'")
         url = f"{self.base_url}/groups/{uuid}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_groups(
-        self, organization=None, page_token=None, count=None
-    ) -> dict[str, Any]:
+    async def list_groups(self, organization=None, page_token=None, count=None) -> dict[str, Any]:
         """
         Retrieves a paginated list of groups associated with a specific organization. The result set can be controlled using pagination parameters for the page token and the number of items to return per page.
 
@@ -810,20 +753,12 @@ class CalendlyApp(APIApplication):
             groups
         """
         url = f"{self.base_url}/groups"
-        query_params = {
-            k: v
-            for k, v in [
-                ("organization", organization),
-                ("page_token", page_token),
-                ("count", count),
-            ]
-            if v is not None
-        }
-        response = self._get(url, params=query_params)
+        query_params = {k: v for k, v in [("organization", organization), ("page_token", page_token), ("count", count)] if v is not None}
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_group_relationship(self, uuid) -> dict[str, Any]:
+    async def get_group_relationship(self, uuid) -> dict[str, Any]:
         """
         Retrieves the details of a specific group relationship, which connects an owner (like a user or invitation) to a group, by its unique identifier (UUID). This differs from `list_group_relationships` which fetches a list.
 
@@ -840,13 +775,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'uuid'")
         url = f"{self.base_url}/group_relationships/{uuid}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_group_relationships(
-        self, count=None, page_token=None, organization=None, owner=None, group=None
-    ) -> dict[str, Any]:
+    async def list_group_relationships(self, count=None, page_token=None, organization=None, owner=None, group=None) -> dict[str, Any]:
         """
         Fetches a paginated list of group relationships. The results can be filtered by organization, owner, or a specific group to refine the search and control the returned data set.
 
@@ -867,20 +800,14 @@ class CalendlyApp(APIApplication):
         url = f"{self.base_url}/group_relationships"
         query_params = {
             k: v
-            for k, v in [
-                ("count", count),
-                ("page_token", page_token),
-                ("organization", organization),
-                ("owner", owner),
-                ("group", group),
-            ]
+            for k, v in [("count", count), ("page_token", page_token), ("organization", organization), ("owner", owner), ("group", group)]
             if v is not None
         }
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_routing_form(self, uuid) -> dict[str, Any]:
+    async def get_routing_form(self, uuid) -> dict[str, Any]:
         """
         Retrieves the details of a specific routing form using its unique identifier (UUID). This is distinct from `list_routing_forms`, which fetches a collection, and from functions that retrieve form submissions.
 
@@ -897,13 +824,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'uuid'")
         url = f"{self.base_url}/routing_forms/{uuid}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_routing_forms(
-        self, organization=None, count=None, page_token=None, sort=None
-    ) -> dict[str, Any]:
+    async def list_routing_forms(self, organization=None, count=None, page_token=None, sort=None) -> dict[str, Any]:
         """
         Retrieves a list of routing forms for a specified organization. This function supports pagination using a page token, sorting by creation date, and limiting the number of results returned per request, distinguishing it from `get_routing_form` which fetches a single item.
 
@@ -921,20 +846,13 @@ class CalendlyApp(APIApplication):
         """
         url = f"{self.base_url}/routing_forms"
         query_params = {
-            k: v
-            for k, v in [
-                ("organization", organization),
-                ("count", count),
-                ("page_token", page_token),
-                ("sort", sort),
-            ]
-            if v is not None
+            k: v for k, v in [("organization", organization), ("count", count), ("page_token", page_token), ("sort", sort)] if v is not None
         }
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_routing_form_submission(self, uuid) -> dict[str, Any]:
+    async def get_routing_form_submission(self, uuid) -> dict[str, Any]:
         """
         Fetches details for a single routing form submission using its unique identifier (UUID). It queries the `/routing_form_submissions/{uuid}` endpoint, distinct from `list_routing_form_submissions` which retrieves multiple submissions.
 
@@ -951,13 +869,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'uuid'")
         url = f"{self.base_url}/routing_form_submissions/{uuid}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_routing_form_submissions(
-        self, form=None, count=None, page_token=None, sort=None
-    ) -> dict[str, Any]:
+    async def get_routing_form_submissions(self, form=None, count=None, page_token=None, sort=None) -> dict[str, Any]:
         """
         Retrieves a paginated list of submissions associated with a specific routing form. The results can be sorted by creation date and navigated using count and page_token parameters.
 
@@ -974,23 +890,12 @@ class CalendlyApp(APIApplication):
             routing_form_submissions
         """
         url = f"{self.base_url}/routing_form_submissions"
-        query_params = {
-            k: v
-            for k, v in [
-                ("form", form),
-                ("count", count),
-                ("page_token", page_token),
-                ("sort", sort),
-            ]
-            if v is not None
-        }
-        response = self._get(url, params=query_params)
+        query_params = {k: v for k, v in [("form", form), ("count", count), ("page_token", page_token), ("sort", sort)] if v is not None}
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_event_type_available_times(
-        self, event_type=None, start_time=None, end_time=None
-    ) -> dict[str, Any]:
+    async def list_event_type_available_times(self, event_type=None, start_time=None, end_time=None) -> dict[str, Any]:
         """
         Retrieves a list of concrete, bookable time slots for a specific event type within a defined start and end time. It provides specific availability, distinct from functions that list a user's general busy times or configured schedules.
 
@@ -1006,20 +911,12 @@ class CalendlyApp(APIApplication):
             event_type_available_times
         """
         url = f"{self.base_url}/event_type_available_times"
-        query_params = {
-            k: v
-            for k, v in [
-                ("event_type", event_type),
-                ("start_time", start_time),
-                ("end_time", end_time),
-            ]
-            if v is not None
-        }
-        response = self._get(url, params=query_params)
+        query_params = {k: v for k, v in [("event_type", event_type), ("start_time", start_time), ("end_time", end_time)] if v is not None}
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_activity_log_entries(
+    async def list_activity_log_entries(
         self,
         organization=None,
         search_term=None,
@@ -1070,11 +967,11 @@ class CalendlyApp(APIApplication):
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def create_shareable_link(
+    async def create_shareable_link(
         self,
         availability_rule=None,
         duration=None,
@@ -1187,13 +1084,11 @@ class CalendlyApp(APIApplication):
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/shares"
         query_params = {}
-        response = self._post(url, data=request_body, params=query_params)
+        response = await self._apost(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_user_busy_times(
-        self, user=None, start_time=None, end_time=None
-    ) -> dict[str, Any]:
+    async def list_user_busy_times(self, user=None, start_time=None, end_time=None) -> dict[str, Any]:
         """
         Fetches a user's busy time intervals within a specified date range, including all scheduled events. This helps determine actual unavailability, differing from `list_user_availability_schedules` which retrieves a user's general working hours.
 
@@ -1209,20 +1104,12 @@ class CalendlyApp(APIApplication):
             user_busy_times
         """
         url = f"{self.base_url}/user_busy_times"
-        query_params = {
-            k: v
-            for k, v in [
-                ("user", user),
-                ("start_time", start_time),
-                ("end_time", end_time),
-            ]
-            if v is not None
-        }
-        response = self._get(url, params=query_params)
+        query_params = {k: v for k, v in [("user", user), ("start_time", start_time), ("end_time", end_time)] if v is not None}
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_user_availability_schedule(self, uuid) -> dict[str, Any]:
+    async def get_user_availability_schedule(self, uuid) -> dict[str, Any]:
         """
         Retrieves a specific user availability schedule by its unique identifier (UUID). It fetches a single schedule resource, unlike `list_user_availability_schedules`, which returns all schedules associated with a user.
 
@@ -1239,11 +1126,11 @@ class CalendlyApp(APIApplication):
             raise ValueError("Missing required parameter 'uuid'")
         url = f"{self.base_url}/user_availability_schedules/{uuid}"
         query_params = {}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_schedules_for_user(self, user=None) -> dict[str, Any]:
+    async def list_schedules_for_user(self, user=None) -> dict[str, Any]:
         """
         Retrieves all availability schedules for a specified user via their URI. Unlike `get_user_availability_schedule`, which fetches a single schedule by its UUID, this function returns a collection of all schedules defining a user's availability intervals.
 
@@ -1258,13 +1145,11 @@ class CalendlyApp(APIApplication):
         """
         url = f"{self.base_url}/user_availability_schedules"
         query_params = {k: v for k, v in [("user", user)] if v is not None}
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def list_event_type_memberships(
-        self, event_type=None, count=None, page_token=None
-    ) -> dict[str, Any]:
+    async def list_event_type_memberships(self, event_type=None, count=None, page_token=None) -> dict[str, Any]:
         """
         Retrieves a paginated list of all user memberships (hosts) for a specific event type. It requires the event type's URI and allows for navigating through results using `count` and `page_token` parameters, returning the membership objects.
 
@@ -1280,28 +1165,13 @@ class CalendlyApp(APIApplication):
             event_type_memberships
         """
         url = f"{self.base_url}/event_type_memberships"
-        query_params = {
-            k: v
-            for k, v in [
-                ("event_type", event_type),
-                ("count", count),
-                ("page_token", page_token),
-            ]
-            if v is not None
-        }
-        response = self._get(url, params=query_params)
+        query_params = {k: v for k, v in [("event_type", event_type), ("count", count), ("page_token", page_token)] if v is not None}
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def create_one_off_event_type(
-        self,
-        co_hosts=None,
-        date_setting=None,
-        duration=None,
-        host=None,
-        location=None,
-        name=None,
-        timezone=None,
+    async def create_one_off_event_type(
+        self, co_hosts=None, date_setting=None, duration=None, host=None, location=None, name=None, timezone=None
     ) -> dict[str, Any]:
         """
         Creates a unique, non-reusable event type for a single, ad-hoc meeting. It defines event details like host, co-hosts, duration, and location, distinguishing it from standard, reusable event types.
@@ -1352,13 +1222,11 @@ class CalendlyApp(APIApplication):
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/one_off_event_types"
         query_params = {}
-        response = self._post(url, data=request_body, params=query_params)
+        response = await self._apost(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def get_sample_webhook_data(
-        self, event=None, organization=None, user=None, scope=None
-    ) -> dict[str, Any]:
+    async def get_sample_webhook_data(self, event=None, organization=None, user=None, scope=None) -> dict[str, Any]:
         """
         Fetches a sample webhook data payload for a specified event, organization, and scope. This helps developers preview the JSON structure for a webhook notification, facilitating testing and integration without needing to trigger a live event.
 
@@ -1376,16 +1244,9 @@ class CalendlyApp(APIApplication):
         """
         url = f"{self.base_url}/sample_webhook_data"
         query_params = {
-            k: v
-            for k, v in [
-                ("event", event),
-                ("organization", organization),
-                ("user", user),
-                ("scope", scope),
-            ]
-            if v is not None
+            k: v for k, v in [("event", event), ("organization", organization), ("user", user), ("scope", scope)] if v is not None
         }
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         response.raise_for_status()
         return response.json()