authpi-admin 0.3.0__py3-none-any.whl

authpi_admin/generated/resources/deliveries.py

@@ -0,0 +1,83 @@
+"""Generated resource class for deliveries — DO NOT EDIT."""
+
+from __future__ import annotations
+
+from typing import Any, AsyncIterator
+
+from authpi_admin.http_client import HttpClient, validate_path_segment as _validate_path_segment
+from authpi_admin.pagination import Page, auto_paginate
+
+
+class DeliveriesResource:
+    """Operations on deliveries."""
+
+    def __init__(self, client: HttpClient, base_path: str) -> None:
+        self._client = client
+        self._base_path = base_path
+
+    async def list(
+        self,
+        limit: int | None = None,
+        cursor: str | None = None,
+        event_type: str | None = None,
+        status: str | None = None,
+        after: float | None = None,
+        before: float | None = None,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Page[dict[str, Any]]:
+        """List Webhook Deliveries"""
+        query: dict[str, Any] = {}
+        if limit is not None:
+            query["limit"] = limit
+        if cursor is not None:
+            query["cursor"] = cursor
+        if event_type is not None:
+            query["event_type"] = event_type
+        if status is not None:
+            query["status"] = status
+        if after is not None:
+            query["after"] = after
+        if before is not None:
+            query["before"] = before
+        resp = await self._client.request(
+            "GET",
+            self._base_path,
+            query=query or None,
+            timeout=timeout,
+            headers=headers,
+        )
+        data = resp.data
+        items = data.get("data", []) if data else []
+        return Page(
+            data=items,
+            has_more=data.get("has_more", False) if data else False,
+            next_cursor=data.get("next_cursor") if data else None,
+        )
+
+    async def list_all(
+        self,
+        limit: int | None = None,
+        event_type: str | None = None,
+        status: str | None = None,
+        after: float | None = None,
+        before: float | None = None,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Auto-paginating iterator over all deliveries."""
+        async def _fetch(cursor: str | None = None) -> Page[dict[str, Any]]:
+            return await self.list(
+                limit=limit,
+                event_type=event_type,
+                status=status,
+                after=after,
+                before=before,
+                cursor=cursor,
+                timeout=timeout,
+                headers=headers,
+            )
+        async for item in auto_paginate(_fetch):
+            yield item

authpi_admin/generated/resources/domains.py

@@ -0,0 +1,194 @@
+"""Generated resource class for domains — DO NOT EDIT."""
+
+from __future__ import annotations
+
+from typing import Any, AsyncIterator
+
+from authpi_admin.http_client import HttpClient, validate_path_segment as _validate_path_segment
+from authpi_admin.pagination import Page, auto_paginate
+
+
+class DomainsResource:
+    """Operations on domains."""
+
+    def __init__(self, client: HttpClient, base_path: str) -> None:
+        self._client = client
+        self._base_path = base_path
+
+    async def list(
+        self,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Page[dict[str, Any]]:
+        """List Account Domains"""
+        query: dict[str, Any] = {}
+        resp = await self._client.request(
+            "GET",
+            self._base_path,
+            query=query or None,
+            timeout=timeout,
+            headers=headers,
+        )
+        data = resp.data
+        items = data.get("data", []) if data else []
+        return Page(
+            data=items,
+            has_more=data.get("has_more", False) if data else False,
+            next_cursor=data.get("next_cursor") if data else None,
+        )
+
+    async def list_all(
+        self,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Auto-paginating iterator over all domains."""
+        async def _fetch(cursor: str | None = None) -> Page[dict[str, Any]]:
+            return await self.list(
+                timeout=timeout,
+                headers=headers,
+            )
+        async for item in auto_paginate(_fetch):
+            yield item
+
+    async def create(
+        self,
+        body: dict[str, Any],
+        *,
+        idempotency_key: str | None = None,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """Add Account Domain"""
+        req_headers: dict[str, str] = {}
+        if headers:
+            req_headers.update(headers)
+        if idempotency_key:
+            req_headers["idempotency-key"] = idempotency_key
+        resp = await self._client.request(
+            "POST",
+            self._base_path,
+            body=body,
+            timeout=timeout,
+            headers=req_headers or None,
+        )
+        data = resp.data
+        if resp.etag and isinstance(data, dict):
+            data["_etag"] = resp.etag
+        return data
+
+    async def delete(
+        self,
+        domain: str,
+        *,
+        if_match: str | None = None,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        """Remove Account Domain"""
+        path = f"{self._base_path}/{domain}"
+        req_headers: dict[str, str] = {}
+        if headers:
+            req_headers.update(headers)
+        if if_match:
+            req_headers["if-match"] = if_match
+        await self._client.request(
+            "DELETE",
+            path,
+            timeout=timeout,
+            headers=req_headers or None,
+        )
+
+    async def assign(
+        self,
+        domain: str,
+        body: dict[str, Any] | None = None,
+        *,
+        if_match: str | None = None,
+        idempotency_key: str | None = None,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """Assign Domain to Issuer"""
+        _validate_path_segment(domain, "domain")
+        path = f"{self._base_path}/{domain}/assign"
+        req_headers: dict[str, str] = {}
+        if headers:
+            req_headers.update(headers)
+        if if_match:
+            req_headers["if-match"] = if_match
+        if idempotency_key:
+            req_headers["idempotency-key"] = idempotency_key
+        resp = await self._client.request(
+            "POST",
+            path,
+            body=body,
+            timeout=timeout,
+            headers=req_headers or None,
+        )
+        data = resp.data
+        if resp.etag and isinstance(data, dict):
+            data["_etag"] = resp.etag
+        return data
+
+    async def unassign(
+        self,
+        domain: str,
+        *,
+        if_match: str | None = None,
+        idempotency_key: str | None = None,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """Unassign Domain from Issuer"""
+        _validate_path_segment(domain, "domain")
+        path = f"{self._base_path}/{domain}/unassign"
+        req_headers: dict[str, str] = {}
+        if headers:
+            req_headers.update(headers)
+        if if_match:
+            req_headers["if-match"] = if_match
+        if idempotency_key:
+            req_headers["idempotency-key"] = idempotency_key
+        resp = await self._client.request(
+            "POST",
+            path,
+            timeout=timeout,
+            headers=req_headers or None,
+        )
+        data = resp.data
+        if resp.etag and isinstance(data, dict):
+            data["_etag"] = resp.etag
+        return data
+
+    async def verify(
+        self,
+        domain: str,
+        *,
+        if_match: str | None = None,
+        idempotency_key: str | None = None,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """Verify Account Domain"""
+        _validate_path_segment(domain, "domain")
+        path = f"{self._base_path}/{domain}/verify"
+        req_headers: dict[str, str] = {}
+        if headers:
+            req_headers.update(headers)
+        if if_match:
+            req_headers["if-match"] = if_match
+        if idempotency_key:
+            req_headers["idempotency-key"] = idempotency_key
+        resp = await self._client.request(
+            "POST",
+            path,
+            timeout=timeout,
+            headers=req_headers or None,
+        )
+        data = resp.data
+        if resp.etag and isinstance(data, dict):
+            data["_etag"] = resp.etag
+        return data

authpi_admin/generated/resources/events.py

@@ -0,0 +1,111 @@
+"""Generated resource class for events — DO NOT EDIT."""
+
+from __future__ import annotations
+
+from typing import Any, AsyncIterator
+
+from authpi_admin.http_client import HttpClient, validate_path_segment as _validate_path_segment
+from authpi_admin.pagination import Page, auto_paginate
+from authpi_admin.generated.models import (
+    Event,
+)
+
+
+class EventsResource:
+    """Operations on events."""
+
+    def __init__(self, client: HttpClient, base_path: str) -> None:
+        self._client = client
+        self._base_path = base_path
+
+    async def list(
+        self,
+        limit: int | None = None,
+        cursor: str | None = None,
+        issuer_id: str | None = None,
+        user_id: str | None = None,
+        client_id: str | None = None,
+        event_types: str | None = None,
+        after: float | None = None,
+        before: float | None = None,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Page[Event]:
+        """List Events"""
+        query: dict[str, Any] = {}
+        if limit is not None:
+            query["limit"] = limit
+        if cursor is not None:
+            query["cursor"] = cursor
+        if issuer_id is not None:
+            query["issuer_id"] = issuer_id
+        if user_id is not None:
+            query["user_id"] = user_id
+        if client_id is not None:
+            query["client_id"] = client_id
+        if event_types is not None:
+            query["event_types"] = event_types
+        if after is not None:
+            query["after"] = after
+        if before is not None:
+            query["before"] = before
+        resp = await self._client.request(
+            "GET",
+            self._base_path,
+            query=query or None,
+            timeout=timeout,
+            headers=headers,
+        )
+        data = resp.data
+        items = [Event(**item) for item in data.get("data", [])] if data else []
+        return Page(
+            data=items,
+            has_more=data.get("has_more", False) if data else False,
+            next_cursor=data.get("next_cursor") if data else None,
+        )
+
+    async def list_all(
+        self,
+        limit: int | None = None,
+        issuer_id: str | None = None,
+        user_id: str | None = None,
+        client_id: str | None = None,
+        event_types: str | None = None,
+        after: float | None = None,
+        before: float | None = None,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> AsyncIterator[Event]:
+        """Auto-paginating iterator over all events."""
+        async def _fetch(cursor: str | None = None) -> Page[Event]:
+            return await self.list(
+                limit=limit,
+                issuer_id=issuer_id,
+                user_id=user_id,
+                client_id=client_id,
+                event_types=event_types,
+                after=after,
+                before=before,
+                cursor=cursor,
+                timeout=timeout,
+                headers=headers,
+            )
+        async for item in auto_paginate(_fetch):
+            yield item
+
+    async def get(
+        self,
+        event_id: str,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """Get Event"""
+        path = f"{self._base_path}/{event_id}"
+        resp = await self._client.request("GET", path, timeout=timeout, headers=headers)
+        data = resp.data
+        if resp.etag and isinstance(data, dict):
+            data["_etag"] = resp.etag
+        return data

authpi_admin/generated/resources/groups.py

@@ -0,0 +1,160 @@
+"""Generated resource class for groups — DO NOT EDIT."""
+
+from __future__ import annotations
+
+from typing import Any, AsyncIterator
+
+from authpi_admin.http_client import HttpClient, validate_path_segment as _validate_path_segment
+from authpi_admin.pagination import Page, auto_paginate
+
+
+class GroupsResource:
+    """Operations on groups."""
+
+    def __init__(self, client: HttpClient, base_path: str) -> None:
+        self._client = client
+        self._base_path = base_path
+
+    async def list(
+        self,
+        limit: int | None = None,
+        cursor: str | None = None,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Page[dict[str, Any]]:
+        """List Organization Groups"""
+        query: dict[str, Any] = {}
+        if limit is not None:
+            query["limit"] = limit
+        if cursor is not None:
+            query["cursor"] = cursor
+        resp = await self._client.request(
+            "GET",
+            self._base_path,
+            query=query or None,
+            timeout=timeout,
+            headers=headers,
+        )
+        data = resp.data
+        items = data.get("data", []) if data else []
+        return Page(
+            data=items,
+            has_more=data.get("has_more", False) if data else False,
+            next_cursor=data.get("next_cursor") if data else None,
+        )
+
+    async def list_all(
+        self,
+        limit: int | None = None,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Auto-paginating iterator over all groups."""
+        async def _fetch(cursor: str | None = None) -> Page[dict[str, Any]]:
+            return await self.list(
+                limit=limit,
+                cursor=cursor,
+                timeout=timeout,
+                headers=headers,
+            )
+        async for item in auto_paginate(_fetch):
+            yield item
+
+    async def create(
+        self,
+        body: dict[str, Any],
+        *,
+        idempotency_key: str | None = None,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """Create Organization Group"""
+        req_headers: dict[str, str] = {}
+        if headers:
+            req_headers.update(headers)
+        if idempotency_key:
+            req_headers["idempotency-key"] = idempotency_key
+        resp = await self._client.request(
+            "POST",
+            self._base_path,
+            body=body,
+            timeout=timeout,
+            headers=req_headers or None,
+        )
+        data = resp.data
+        if resp.etag and isinstance(data, dict):
+            data["_etag"] = resp.etag
+        return data
+
+    async def get(
+        self,
+        org_id: str,
+        group_id: str,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """Get Organization Group"""
+        path = f"{self._base_path}/{org_id}/{group_id}"
+        resp = await self._client.request("GET", path, timeout=timeout, headers=headers)
+        data = resp.data
+        if resp.etag and isinstance(data, dict):
+            data["_etag"] = resp.etag
+        return data
+
+    async def update(
+        self,
+        org_id: str,
+        group_id: str,
+        body: dict[str, Any],
+        *,
+        if_match: str | None = None,
+        idempotency_key: str | None = None,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """Update Organization Group"""
+        path = f"{self._base_path}/{org_id}/{group_id}"
+        req_headers: dict[str, str] = {}
+        if headers:
+            req_headers.update(headers)
+        if if_match:
+            req_headers["if-match"] = if_match
+        if idempotency_key:
+            req_headers["idempotency-key"] = idempotency_key
+        resp = await self._client.request(
+            "PATCH",
+            path,
+            body=body,
+            timeout=timeout,
+            headers=req_headers or None,
+        )
+        data = resp.data
+        if resp.etag and isinstance(data, dict):
+            data["_etag"] = resp.etag
+        return data
+
+    async def delete(
+        self,
+        org_id: str,
+        group_id: str,
+        *,
+        if_match: str | None = None,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        """Delete Organization Group"""
+        path = f"{self._base_path}/{org_id}/{group_id}"
+        req_headers: dict[str, str] = {}
+        if headers:
+            req_headers.update(headers)
+        if if_match:
+            req_headers["if-match"] = if_match
+        await self._client.request(
+            "DELETE",
+            path,
+            timeout=timeout,
+            headers=req_headers or None,
+        )