authpi-admin 0.3.0__py3-none-any.whl

authpi_admin/generated/resources/users.py

@@ -0,0 +1,224 @@
+"""Generated resource class for users — 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 UsersResource:
+    """Operations on users."""
+
+    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,
+        status: str | None = None,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Page[dict[str, Any]]:
+        """List Users"""
+        query: dict[str, Any] = {}
+        if limit is not None:
+            query["limit"] = limit
+        if cursor is not None:
+            query["cursor"] = cursor
+        if status is not None:
+            query["status"] = status
+        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,
+        status: str | None = None,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Auto-paginating iterator over all users."""
+        async def _fetch(cursor: str | None = None) -> Page[dict[str, Any]]:
+            return await self.list(
+                limit=limit,
+                status=status,
+                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 User"""
+        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,
+        resource_id: str,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """Get User"""
+        path = f"{self._base_path}/{resource_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,
+        resource_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 User"""
+        path = f"{self._base_path}/{resource_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,
+        resource_id: str,
+        *,
+        if_match: str | None = None,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        """Delete User"""
+        path = f"{self._base_path}/{resource_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,
+        )
+
+    async def revoke_all_trusted_devices(
+        self,
+        user_id: str,
+        *,
+        if_match: str | None = None,
+        idempotency_key: str | None = None,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """Revoke All Trusted Devices"""
+        _validate_path_segment(user_id, "user_id")
+        path = f"{self._base_path}/{user_id}/trusted-devices/revoke-all"
+        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 complete_enrollment_verifiers(
+        self,
+        user_id: 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]:
+        """Complete Verifier Enrollment"""
+        _validate_path_segment(user_id, "user_id")
+        path = f"{self._base_path}/{user_id}/verifiers/complete-enrollment"
+        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

authpi_admin/generated/resources/verifiers.py

@@ -0,0 +1,102 @@
+"""Generated resource class for verifiers — 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 VerifiersResource:
+    """Operations on verifiers."""
+
+    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 Agent Verifiers"""
+        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 verifiers."""
+        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 Agent Verifier"""
+        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,
+        verifier_id: str,
+        *,
+        if_match: str | None = None,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        """Remove Agent Verifier"""
+        path = f"{self._base_path}/{verifier_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,
+        )

authpi_admin/generated/resources/webhooks.py

@@ -0,0 +1,167 @@
+"""Generated resource class for webhooks — 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 (
+    WebhookListItem,
+    CreateWebhookInput,
+    UpdateWebhook,
+)
+
+
+class WebhooksResource:
+    """Operations on webhooks."""
+
+    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,
+        status: str | None = None,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Page[WebhookListItem]:
+        """List Webhooks"""
+        query: dict[str, Any] = {}
+        if limit is not None:
+            query["limit"] = limit
+        if cursor is not None:
+            query["cursor"] = cursor
+        if status is not None:
+            query["status"] = status
+        resp = await self._client.request(
+            "GET",
+            self._base_path,
+            query=query or None,
+            timeout=timeout,
+            headers=headers,
+        )
+        data = resp.data
+        items = [WebhookListItem(**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,
+        status: str | None = None,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> AsyncIterator[WebhookListItem]:
+        """Auto-paginating iterator over all webhooks."""
+        async def _fetch(cursor: str | None = None) -> Page[WebhookListItem]:
+            return await self.list(
+                limit=limit,
+                status=status,
+                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 Webhook"""
+        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,
+        resource_id: str,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """Get Webhook"""
+        path = f"{self._base_path}/{resource_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,
+        resource_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 Webhook"""
+        path = f"{self._base_path}/{resource_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,
+        resource_id: str,
+        *,
+        if_match: str | None = None,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        """Delete Webhook"""
+        path = f"{self._base_path}/{resource_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,
+        )

authpi_admin/generated/scopes/agent_scope.py

@@ -0,0 +1,84 @@
+"""Generated scope class for AgentScope — DO NOT EDIT."""
+
+from __future__ import annotations
+
+from functools import cached_property
+from typing import Any, TYPE_CHECKING
+
+from authpi_admin.http_client import validate_path_segment as _validate_path_segment
+
+if TYPE_CHECKING:
+    from authpi_admin.http_client import HttpClient
+from authpi_admin.generated.resources.verifiers import VerifiersResource
+
+
+class AgentScope:
+    """Scope for operations under a specific agent."""
+
+    def __init__(self, client: HttpClient, base_path: str, agent_id: str) -> None:
+        _validate_path_segment(agent_id, "agent_id")
+        self._client = client
+        self._base_path = base_path
+        self._agent_id = agent_id
+        self._path = f"{base_path}/{agent_id}"
+
+    @cached_property
+    def verifiers(self) -> VerifiersResource:
+        """Access verifiers under this agent."""
+        return VerifiersResource(self._client, f"{self._path}/verifiers")
+
+    async def get(
+        self,
+        *,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Any:
+        """Get Agent"""
+        resp = await self._client.request("GET", self._path, timeout=timeout, headers=headers)
+        return resp.data
+
+    async def update(
+        self,
+        body: dict[str, Any],
+        *,
+        if_match: str | None = None,
+        idempotency_key: str | None = None,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Any:
+        """Update Agent"""
+        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",
+            self._path,
+            body=body,
+            timeout=timeout,
+            headers=req_headers or None,
+        )
+        return resp.data
+
+    async def delete(
+        self,
+        *,
+        if_match: str | None = None,
+        timeout: float | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        """Delete Agent"""
+        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",
+            self._path,
+            timeout=timeout,
+            headers=req_headers or None,
+        )