circle-so-python-sdk 0.1.0__py3-none-any.whl

circle/__init__.py

@@ -0,0 +1,24 @@
+"""Circle.so Python SDK - Admin V2, Headless Auth, and Headless Client V1 APIs."""
+
+__version__ = "0.1.0"
+
+from circle.client import AsyncCircleClient, CircleClient
+from circle.exceptions import (
+    AuthenticationError,
+    CircleAPIError,
+    ForbiddenError,
+    NotFoundError,
+    RateLimitError,
+    ValidationError,
+)
+
+__all__ = [
+    "CircleClient",
+    "AsyncCircleClient",
+    "CircleAPIError",
+    "AuthenticationError",
+    "NotFoundError",
+    "ValidationError",
+    "ForbiddenError",
+    "RateLimitError",
+]

circle/api/__init__.py

@@ -0,0 +1 @@
+"""API client sub-packages."""

circle/api/admin_access_groups.py

@@ -0,0 +1,133 @@
+"""Admin API -- Access Groups & Access Group Members."""
+from __future__ import annotations
+from typing import Any, Dict, Optional
+from circle.constants import ADMIN_V2_PREFIX as _P
+from circle.http import AsyncTransport, SyncTransport
+from circle.models.admin.misc import (
+    AccessGroup, AccessGroupList, AccessGroupCommunityMember, AccessGroupCommunityMemberList,
+)
+
+
+# -- param builders ----------------------------------------------------------
+
+def _list_params(page: int, per_page: int, status: Optional[str],
+                 ids: Optional[list[int]], name: Optional[str]) -> Dict[str, Any]:
+    p: Dict[str, Any] = {"page": page, "per_page": per_page}
+    if status: p["status"] = status
+    if ids: p["ids"] = ids
+    if name: p["name"] = name
+    return p
+
+
+def _create_body(name: str, description: Optional[str]) -> Dict[str, Any]:
+    ag: Dict[str, Any] = {"name": name}
+    if description is not None: ag["description"] = description
+    return {"access_group": ag}
+
+
+def _page_params(page: int, per_page: int) -> Dict[str, Any]:
+    return {"page": page, "per_page": per_page}
+
+
+# -- sync client --------------------------------------------------------------
+
+class AccessGroupsClient:
+    def __init__(self, transport: SyncTransport) -> None:
+        self._t = transport
+
+    def list_access_groups(self, *, page: int = 1, per_page: int = 60, status: Optional[str] = None,
+                           ids: Optional[list[int]] = None, name: Optional[str] = None) -> AccessGroupList:
+        return AccessGroupList.model_validate(
+            self._t.request("GET", f"{_P}/access_groups", params=_list_params(page, per_page, status, ids, name)))
+
+    def create_access_group(self, *, name: str, description: Optional[str] = None) -> AccessGroup:
+        return AccessGroup.model_validate(
+            self._t.request("POST", f"{_P}/access_groups", json=_create_body(name, description)))
+
+    def update_access_group(self, access_group_id: int, **kwargs: Any) -> AccessGroup:
+        return AccessGroup.model_validate(
+            self._t.request("PUT", f"{_P}/access_groups/{access_group_id}", json={"access_group": kwargs}))
+
+    def archive_access_group(self, access_group_id: int) -> Dict[str, Any]:
+        return self._t.request("DELETE", f"{_P}/access_groups/{access_group_id}")
+
+    def unarchive_access_group(self, access_group_id: int) -> AccessGroup:
+        return AccessGroup.model_validate(
+            self._t.request("PATCH", f"{_P}/access_groups/{access_group_id}/unarchive"))
+
+    def list_access_group_members(self, access_group_id: int, *, page: int = 1,
+                                  per_page: int = 60) -> AccessGroupCommunityMemberList:
+        return AccessGroupCommunityMemberList.model_validate(
+            self._t.request("GET", f"{_P}/access_groups/{access_group_id}/community_members",
+                            params=_page_params(page, per_page)))
+
+    def show_access_group_member(self, access_group_id: int, *, email: str) -> AccessGroupCommunityMember:
+        return AccessGroupCommunityMember.model_validate(
+            self._t.request("GET", f"{_P}/access_groups/{access_group_id}/community_member",
+                            params={"email": email}))
+
+    def add_access_group_member(self, access_group_id: int, *, email: str) -> Dict[str, Any]:
+        return self._t.request("POST", f"{_P}/access_groups/{access_group_id}/community_members",
+                               json={"email": email})
+
+    def remove_access_group_member(self, access_group_id: int, *, email: str) -> Dict[str, Any]:
+        return self._t.request("DELETE", f"{_P}/access_groups/{access_group_id}/community_members",
+                               params={"email": email})
+
+    def list_community_member_access_groups(self, community_member_id: int, *, page: int = 1,
+                                            per_page: int = 60) -> AccessGroupList:
+        return AccessGroupList.model_validate(
+            self._t.request("GET", f"{_P}/community_members/{community_member_id}/access_groups",
+                            params=_page_params(page, per_page)))
+
+
+# -- async client --------------------------------------------------------------
+
+class AsyncAccessGroupsClient:
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._t = transport
+
+    async def list_access_groups(self, *, page: int = 1, per_page: int = 60, status: Optional[str] = None,
+                                 ids: Optional[list[int]] = None, name: Optional[str] = None) -> AccessGroupList:
+        return AccessGroupList.model_validate(
+            await self._t.request("GET", f"{_P}/access_groups", params=_list_params(page, per_page, status, ids, name)))
+
+    async def create_access_group(self, *, name: str, description: Optional[str] = None) -> AccessGroup:
+        return AccessGroup.model_validate(
+            await self._t.request("POST", f"{_P}/access_groups", json=_create_body(name, description)))
+
+    async def update_access_group(self, access_group_id: int, **kwargs: Any) -> AccessGroup:
+        return AccessGroup.model_validate(
+            await self._t.request("PUT", f"{_P}/access_groups/{access_group_id}", json={"access_group": kwargs}))
+
+    async def archive_access_group(self, access_group_id: int) -> Dict[str, Any]:
+        return await self._t.request("DELETE", f"{_P}/access_groups/{access_group_id}")
+
+    async def unarchive_access_group(self, access_group_id: int) -> AccessGroup:
+        return AccessGroup.model_validate(
+            await self._t.request("PATCH", f"{_P}/access_groups/{access_group_id}/unarchive"))
+
+    async def list_access_group_members(self, access_group_id: int, *, page: int = 1,
+                                        per_page: int = 60) -> AccessGroupCommunityMemberList:
+        return AccessGroupCommunityMemberList.model_validate(
+            await self._t.request("GET", f"{_P}/access_groups/{access_group_id}/community_members",
+                                  params=_page_params(page, per_page)))
+
+    async def show_access_group_member(self, access_group_id: int, *, email: str) -> AccessGroupCommunityMember:
+        return AccessGroupCommunityMember.model_validate(
+            await self._t.request("GET", f"{_P}/access_groups/{access_group_id}/community_member",
+                                  params={"email": email}))
+
+    async def add_access_group_member(self, access_group_id: int, *, email: str) -> Dict[str, Any]:
+        return await self._t.request("POST", f"{_P}/access_groups/{access_group_id}/community_members",
+                                     json={"email": email})
+
+    async def remove_access_group_member(self, access_group_id: int, *, email: str) -> Dict[str, Any]:
+        return await self._t.request("DELETE", f"{_P}/access_groups/{access_group_id}/community_members",
+                                     params={"email": email})
+
+    async def list_community_member_access_groups(self, community_member_id: int, *, page: int = 1,
+                                                  per_page: int = 60) -> AccessGroupList:
+        return AccessGroupList.model_validate(
+            await self._t.request("GET", f"{_P}/community_members/{community_member_id}/access_groups",
+                                  params=_page_params(page, per_page)))

circle/api/admin_community.py

@@ -0,0 +1,122 @@
+"""Admin API -- Community & Community Members."""
+from __future__ import annotations
+from typing import Any, Dict, Optional
+from circle.constants import ADMIN_V2_PREFIX as _P
+from circle.http import AsyncTransport, SyncTransport
+from circle.models.admin.community import Community
+from circle.models.admin.members import CommunityMember, CommunityMemberList, CommunityMemberCreated
+from circle.models.admin.spaces import SpaceList
+
+
+def _list_members_params(page: int, per_page: int, status: Optional[str]) -> Dict[str, Any]:
+    p: Dict[str, Any] = {"page": page, "per_page": per_page}
+    if status:
+        p["status"] = status
+    return p
+
+
+def _member_spaces_params(
+    page: int, per_page: int,
+    community_member_id: Optional[int], user_email: Optional[str],
+) -> Dict[str, Any]:
+    p: Dict[str, Any] = {"page": page, "per_page": per_page}
+    if community_member_id:
+        p["community_member_id"] = community_member_id
+    if user_email:
+        p["user_email"] = user_email
+    return p
+
+
+class CommunityClient:
+    def __init__(self, transport: SyncTransport) -> None:
+        self._t = transport
+
+    def get_community(self) -> Community:
+        return Community.model_validate(self._t.request("GET", f"{_P}/community"))
+
+    def update_community(self, **kwargs: Any) -> Community:
+        return Community.model_validate(self._t.request("PUT", f"{_P}/community", json={"community": kwargs}))
+
+    def list_community_members(self, *, page: int = 1, per_page: int = 10,
+                               status: Optional[str] = None) -> CommunityMemberList:
+        return CommunityMemberList.model_validate(
+            self._t.request("GET", f"{_P}/community_members", params=_list_members_params(page, per_page, status)))
+
+    def create_community_member(self, *, email: str, **kwargs: Any) -> CommunityMemberCreated:
+        return CommunityMemberCreated.model_validate(
+            self._t.request("POST", f"{_P}/community_members", json={"email": email, **kwargs}))
+
+    def show_community_member(self, member_id: int) -> CommunityMember:
+        return CommunityMember.model_validate(self._t.request("GET", f"{_P}/community_members/{member_id}"))
+
+    def update_community_member(self, member_id: int, **kwargs: Any) -> CommunityMember:
+        return CommunityMember.model_validate(
+            self._t.request("PUT", f"{_P}/community_members/{member_id}", json=kwargs))
+
+    def deactivate_community_member(self, member_id: int) -> Dict[str, Any]:
+        return self._t.request("DELETE", f"{_P}/community_members/{member_id}")
+
+    def search_community_member(self, *, email: str) -> CommunityMember:
+        return CommunityMember.model_validate(
+            self._t.request("GET", f"{_P}/community_members/search", params={"email": email}))
+
+    def ban_community_member(self, member_id: int) -> Dict[str, Any]:
+        return self._t.request("PUT", f"{_P}/community_members/{member_id}/ban_member")
+
+    def delete_community_member(self, member_id: int) -> Dict[str, Any]:
+        return self._t.request("PUT", f"{_P}/community_members/{member_id}/delete_member")
+
+    def list_community_member_spaces(self, *, page: int = 1, per_page: int = 60,
+                                     community_member_id: Optional[int] = None,
+                                     user_email: Optional[str] = None) -> SpaceList:
+        return SpaceList.model_validate(
+            self._t.request("GET", f"{_P}/community_member_spaces",
+                            params=_member_spaces_params(page, per_page, community_member_id, user_email)))
+
+
+class AsyncCommunityClient:
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._t = transport
+
+    async def get_community(self) -> Community:
+        return Community.model_validate(await self._t.request("GET", f"{_P}/community"))
+
+    async def update_community(self, **kwargs: Any) -> Community:
+        return Community.model_validate(await self._t.request("PUT", f"{_P}/community", json={"community": kwargs}))
+
+    async def list_community_members(self, *, page: int = 1, per_page: int = 10,
+                                     status: Optional[str] = None) -> CommunityMemberList:
+        return CommunityMemberList.model_validate(
+            await self._t.request("GET", f"{_P}/community_members",
+                                  params=_list_members_params(page, per_page, status)))
+
+    async def create_community_member(self, *, email: str, **kwargs: Any) -> CommunityMemberCreated:
+        return CommunityMemberCreated.model_validate(
+            await self._t.request("POST", f"{_P}/community_members", json={"email": email, **kwargs}))
+
+    async def show_community_member(self, member_id: int) -> CommunityMember:
+        return CommunityMember.model_validate(await self._t.request("GET", f"{_P}/community_members/{member_id}"))
+
+    async def update_community_member(self, member_id: int, **kwargs: Any) -> CommunityMember:
+        return CommunityMember.model_validate(
+            await self._t.request("PUT", f"{_P}/community_members/{member_id}", json=kwargs))
+
+    async def deactivate_community_member(self, member_id: int) -> Dict[str, Any]:
+        return await self._t.request("DELETE", f"{_P}/community_members/{member_id}")
+
+    async def search_community_member(self, *, email: str) -> CommunityMember:
+        return CommunityMember.model_validate(
+            await self._t.request("GET", f"{_P}/community_members/search", params={"email": email}))
+
+    async def ban_community_member(self, member_id: int) -> Dict[str, Any]:
+        return await self._t.request("PUT", f"{_P}/community_members/{member_id}/ban_member")
+
+    async def delete_community_member(self, member_id: int) -> Dict[str, Any]:
+        return await self._t.request("PUT", f"{_P}/community_members/{member_id}/delete_member")
+
+    async def list_community_member_spaces(self, *, page: int = 1, per_page: int = 60,
+                                           community_member_id: Optional[int] = None,
+                                           user_email: Optional[str] = None) -> SpaceList:
+        return SpaceList.model_validate(
+            await self._t.request("GET", f"{_P}/community_member_spaces",
+                                  params=_member_spaces_params(page, per_page, community_member_id, user_email)))

circle/api/admin_courses.py

@@ -0,0 +1,172 @@
+"""Admin API -- Courses (Sections, Lessons, Progress)."""
+from __future__ import annotations
+from typing import Any, Dict, Optional
+from circle.constants import ADMIN_V2_PREFIX as _P
+from circle.http import AsyncTransport, SyncTransport
+from circle.models.admin.courses import (
+    CourseSection, CourseSectionList, CourseLesson, CourseLessonList,
+)
+
+
+def _list_sections_params(page: int, per_page: int, space_id: Optional[int],
+                          sort: Optional[str]) -> Dict[str, Any]:
+    p: Dict[str, Any] = {"page": page, "per_page": per_page}
+    if space_id:
+        p["space_id"] = space_id
+    if sort:
+        p["sort"] = sort
+    return p
+
+
+def _list_lessons_params(page: int, per_page: int, section_id: Optional[int],
+                         space_id: Optional[int], status: Optional[str],
+                         sort: Optional[str]) -> Dict[str, Any]:
+    p: Dict[str, Any] = {"page": page, "per_page": per_page}
+    if section_id:
+        p["section_id"] = section_id
+    if space_id:
+        p["space_id"] = space_id
+    if status:
+        p["status"] = status
+    if sort:
+        p["sort"] = sort
+    return p
+
+
+# ---------------------------------------------------------------------------
+# Sync client
+# ---------------------------------------------------------------------------
+
+class CoursesClient:
+    def __init__(self, transport: SyncTransport) -> None:
+        self._t = transport
+
+    # -- Sections --
+    def list_course_sections(self, *, page: int = 1, per_page: int = 10,
+                             space_id: Optional[int] = None,
+                             sort: Optional[str] = None) -> CourseSectionList:
+        p = _list_sections_params(page, per_page, space_id, sort)
+        return CourseSectionList.model_validate(
+            self._t.request("GET", f"{_P}/course_sections", params=p))
+
+    def create_course_section(self, *, name: str, space_id: int) -> CourseSection:
+        return CourseSection.model_validate(
+            self._t.request("POST", f"{_P}/course_sections",
+                            json={"name": name, "space_id": space_id}))
+
+    def show_course_section(self, section_id: int) -> CourseSection:
+        return CourseSection.model_validate(
+            self._t.request("GET", f"{_P}/course_sections/{section_id}"))
+
+    def update_course_section(self, section_id: int, *, name: str) -> CourseSection:
+        return CourseSection.model_validate(
+            self._t.request("PUT", f"{_P}/course_sections/{section_id}",
+                            json={"name": name}))
+
+    def delete_course_section(self, section_id: int) -> Dict[str, Any]:
+        return self._t.request("DELETE", f"{_P}/course_sections/{section_id}")
+
+    # -- Lessons --
+    def list_course_lessons(self, *, page: int = 1, per_page: int = 10,
+                            section_id: Optional[int] = None,
+                            space_id: Optional[int] = None,
+                            status: Optional[str] = None,
+                            sort: Optional[str] = None) -> CourseLessonList:
+        p = _list_lessons_params(page, per_page, section_id, space_id, status, sort)
+        return CourseLessonList.model_validate(
+            self._t.request("GET", f"{_P}/course_lessons", params=p))
+
+    def create_course_lesson(self, *, name: str, section_id: int,
+                             **kwargs: Any) -> CourseLesson:
+        return CourseLesson.model_validate(
+            self._t.request("POST", f"{_P}/course_lessons",
+                            json={"name": name, "section_id": section_id, **kwargs}))
+
+    def show_course_lesson(self, lesson_id: int) -> CourseLesson:
+        return CourseLesson.model_validate(
+            self._t.request("GET", f"{_P}/course_lessons/{lesson_id}"))
+
+    def update_course_lesson(self, lesson_id: int, **kwargs: Any) -> CourseLesson:
+        return CourseLesson.model_validate(
+            self._t.request("PATCH", f"{_P}/course_lessons/{lesson_id}", json=kwargs))
+
+    def delete_course_lesson(self, lesson_id: int) -> Dict[str, Any]:
+        return self._t.request("DELETE", f"{_P}/course_lessons/{lesson_id}")
+
+    # -- Progress --
+    def update_course_lesson_progress(self, *, lesson_id: int, member_email: str,
+                                      status: str) -> Dict[str, Any]:
+        return self._t.request("PUT", f"{_P}/course_lesson_progress",
+                               json={"lesson_id": lesson_id,
+                                     "member_email": member_email,
+                                     "status": status})
+
+
+# ---------------------------------------------------------------------------
+# Async client
+# ---------------------------------------------------------------------------
+
+class AsyncCoursesClient:
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._t = transport
+
+    # -- Sections --
+    async def list_course_sections(self, *, page: int = 1, per_page: int = 10,
+                                   space_id: Optional[int] = None,
+                                   sort: Optional[str] = None) -> CourseSectionList:
+        p = _list_sections_params(page, per_page, space_id, sort)
+        return CourseSectionList.model_validate(
+            await self._t.request("GET", f"{_P}/course_sections", params=p))
+
+    async def create_course_section(self, *, name: str, space_id: int) -> CourseSection:
+        return CourseSection.model_validate(
+            await self._t.request("POST", f"{_P}/course_sections",
+                                  json={"name": name, "space_id": space_id}))
+
+    async def show_course_section(self, section_id: int) -> CourseSection:
+        return CourseSection.model_validate(
+            await self._t.request("GET", f"{_P}/course_sections/{section_id}"))
+
+    async def update_course_section(self, section_id: int, *, name: str) -> CourseSection:
+        return CourseSection.model_validate(
+            await self._t.request("PUT", f"{_P}/course_sections/{section_id}",
+                                  json={"name": name}))
+
+    async def delete_course_section(self, section_id: int) -> Dict[str, Any]:
+        return await self._t.request("DELETE", f"{_P}/course_sections/{section_id}")
+
+    # -- Lessons --
+    async def list_course_lessons(self, *, page: int = 1, per_page: int = 10,
+                                  section_id: Optional[int] = None,
+                                  space_id: Optional[int] = None,
+                                  status: Optional[str] = None,
+                                  sort: Optional[str] = None) -> CourseLessonList:
+        p = _list_lessons_params(page, per_page, section_id, space_id, status, sort)
+        return CourseLessonList.model_validate(
+            await self._t.request("GET", f"{_P}/course_lessons", params=p))
+
+    async def create_course_lesson(self, *, name: str, section_id: int,
+                                   **kwargs: Any) -> CourseLesson:
+        return CourseLesson.model_validate(
+            await self._t.request("POST", f"{_P}/course_lessons",
+                                  json={"name": name, "section_id": section_id, **kwargs}))
+
+    async def show_course_lesson(self, lesson_id: int) -> CourseLesson:
+        return CourseLesson.model_validate(
+            await self._t.request("GET", f"{_P}/course_lessons/{lesson_id}"))
+
+    async def update_course_lesson(self, lesson_id: int, **kwargs: Any) -> CourseLesson:
+        return CourseLesson.model_validate(
+            await self._t.request("PATCH", f"{_P}/course_lessons/{lesson_id}",
+                                  json=kwargs))
+
+    async def delete_course_lesson(self, lesson_id: int) -> Dict[str, Any]:
+        return await self._t.request("DELETE", f"{_P}/course_lessons/{lesson_id}")
+
+    # -- Progress --
+    async def update_course_lesson_progress(self, *, lesson_id: int, member_email: str,
+                                            status: str) -> Dict[str, Any]:
+        return await self._t.request("PUT", f"{_P}/course_lesson_progress",
+                                     json={"lesson_id": lesson_id,
+                                           "member_email": member_email,
+                                           "status": status})

circle/api/admin_events.py

@@ -0,0 +1,101 @@
+"""Admin API -- Events & Event Attendees."""
+from __future__ import annotations
+from typing import Any, Dict, Optional
+from circle.constants import ADMIN_V2_PREFIX as _P
+from circle.http import AsyncTransport, SyncTransport
+from circle.models.admin.events import Event, EventList, EventAttendee, EventAttendeeList
+
+
+def _list_events_params(
+    page: int, per_page: int, space_id: Optional[int], sort: Optional[str], **kwargs: Any,
+) -> Dict[str, Any]:
+    p: Dict[str, Any] = {"page": page, "per_page": per_page, **kwargs}
+    if space_id:
+        p["space_id"] = space_id
+    if sort:
+        p["sort"] = sort
+    return p
+
+
+class EventsClient:
+    def __init__(self, transport: SyncTransport) -> None:
+        self._t = transport
+
+    def list_events(self, *, page: int = 1, per_page: int = 60, space_id: Optional[int] = None,
+                    sort: Optional[str] = None, **kwargs: Any) -> EventList:
+        return EventList.model_validate(
+            self._t.request("GET", f"{_P}/events",
+                            params=_list_events_params(page, per_page, space_id, sort, **kwargs)))
+
+    def create_event(self, *, space_id: int, **kwargs: Any) -> Event:
+        return Event.model_validate(
+            self._t.request("POST", f"{_P}/events", json={"event": kwargs, "space_id": space_id}))
+
+    def get_event(self, event_id: int) -> Event:
+        return Event.model_validate(self._t.request("GET", f"{_P}/events/{event_id}"))
+
+    def update_event(self, event_id: int, *, space_id: int, **kwargs: Any) -> Event:
+        return Event.model_validate(
+            self._t.request("PUT", f"{_P}/events/{event_id}", json={"event": kwargs, "space_id": space_id}))
+
+    def delete_event(self, event_id: int, *, space_id: int) -> Dict[str, Any]:
+        return self._t.request("DELETE", f"{_P}/events/{event_id}", params={"space_id": space_id})
+
+    def duplicate_event(self, space_id: int, event_id: int, **kwargs: Any) -> Event:
+        return Event.model_validate(
+            self._t.request("POST", f"{_P}/spaces/{space_id}/events/{event_id}/duplicate", json=kwargs))
+
+    def list_event_attendees(self, *, event_id: int, page: int = 1, per_page: int = 10) -> EventAttendeeList:
+        return EventAttendeeList.model_validate(
+            self._t.request("GET", f"{_P}/event_attendees",
+                            params={"event_id": event_id, "page": page, "per_page": per_page}))
+
+    def create_event_attendee(self, *, event_id: int, member_email: str) -> Dict[str, Any]:
+        return self._t.request("POST", f"{_P}/event_attendees",
+                               json={"event_id": event_id, "member_email": member_email})
+
+    def delete_event_attendee(self, *, event_id: int, member_email: str) -> Dict[str, Any]:
+        return self._t.request("DELETE", f"{_P}/event_attendees",
+                               json={"event_id": event_id, "member_email": member_email})
+
+
+class AsyncEventsClient:
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._t = transport
+
+    async def list_events(self, *, page: int = 1, per_page: int = 60, space_id: Optional[int] = None,
+                          sort: Optional[str] = None, **kwargs: Any) -> EventList:
+        return EventList.model_validate(
+            await self._t.request("GET", f"{_P}/events",
+                                  params=_list_events_params(page, per_page, space_id, sort, **kwargs)))
+
+    async def create_event(self, *, space_id: int, **kwargs: Any) -> Event:
+        return Event.model_validate(
+            await self._t.request("POST", f"{_P}/events", json={"event": kwargs, "space_id": space_id}))
+
+    async def get_event(self, event_id: int) -> Event:
+        return Event.model_validate(await self._t.request("GET", f"{_P}/events/{event_id}"))
+
+    async def update_event(self, event_id: int, *, space_id: int, **kwargs: Any) -> Event:
+        return Event.model_validate(
+            await self._t.request("PUT", f"{_P}/events/{event_id}", json={"event": kwargs, "space_id": space_id}))
+
+    async def delete_event(self, event_id: int, *, space_id: int) -> Dict[str, Any]:
+        return await self._t.request("DELETE", f"{_P}/events/{event_id}", params={"space_id": space_id})
+
+    async def duplicate_event(self, space_id: int, event_id: int, **kwargs: Any) -> Event:
+        return Event.model_validate(
+            await self._t.request("POST", f"{_P}/spaces/{space_id}/events/{event_id}/duplicate", json=kwargs))
+
+    async def list_event_attendees(self, *, event_id: int, page: int = 1, per_page: int = 10) -> EventAttendeeList:
+        return EventAttendeeList.model_validate(
+            await self._t.request("GET", f"{_P}/event_attendees",
+                                  params={"event_id": event_id, "page": page, "per_page": per_page}))
+
+    async def create_event_attendee(self, *, event_id: int, member_email: str) -> Dict[str, Any]:
+        return await self._t.request("POST", f"{_P}/event_attendees",
+                                     json={"event_id": event_id, "member_email": member_email})
+
+    async def delete_event_attendee(self, *, event_id: int, member_email: str) -> Dict[str, Any]:
+        return await self._t.request("DELETE", f"{_P}/event_attendees",
+                                     json={"event_id": event_id, "member_email": member_email})