memorysync 1.3.0__tar.gz → 1.5.0__tar.gz

{memorysync-1.3.0 → memorysync-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: memorysync
-Version: 1.3.0
+Version: 1.5.0
 Summary: Official Python client for the MemorySync API.
 Project-URL: Homepage, https://memorysync.io
 Project-URL: Documentation, https://docs.memorysync.io

{memorysync-1.3.0 → memorysync-1.5.0}/pyproject.toml

@@ -1,44 +1,44 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "memorysync"
-version = "1.3.0"
-description = "Official Python client for the MemorySync API."
-readme = "README.md"
-license = { text = "MIT" }
-requires-python = ">=3.9"
-authors = [{ name = "MemorySync" }]
-keywords = ["memorysync", "memory", "sdk", "client"]
-classifiers = [
-  "Development Status :: 5 - Production/Stable",
-  "Intended Audience :: Developers",
-  "License :: OSI Approved :: MIT License",
-  "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3.9",
-  "Programming Language :: Python :: 3.10",
-  "Programming Language :: Python :: 3.11",
-  "Programming Language :: Python :: 3.12",
-  "Topic :: Software Development :: Libraries :: Python Modules",
-  "Typing :: Typed",
-]
-dependencies = [
-  "httpx>=0.25,<1.0",
-  "typing-extensions>=4.5; python_version < '3.11'",
-]
-
-[project.urls]
-Homepage = "https://memorysync.io"
-Documentation = "https://docs.memorysync.io"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/memorysync"]
-
-[tool.hatch.build.targets.sdist]
-include = [
-  "src/memorysync",
-  "README.md",
-  "LICENSE",
-  "pyproject.toml",
-]
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "memorysync"
+version = "1.5.0"
+description = "Official Python client for the MemorySync API."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.9"
+authors = [{ name = "MemorySync" }]
+keywords = ["memorysync", "memory", "sdk", "client"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Typing :: Typed",
+]
+dependencies = [
+  "httpx>=0.25,<1.0",
+  "typing-extensions>=4.5; python_version < '3.11'",
+]
+
+[project.urls]
+Homepage = "https://memorysync.io"
+Documentation = "https://docs.memorysync.io"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/memorysync"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "src/memorysync",
+  "README.md",
+  "LICENSE",
+  "pyproject.toml",
+]

{memorysync-1.3.0 → memorysync-1.5.0}/src/memorysync/__init__.py

@@ -37,14 +37,20 @@ from .client import AsyncMemorySyncClient, MemorySyncClient
 from .control_plane import AsyncControlPlaneClient, ControlPlaneClient
 from .control_plane_types import (
     ApiKeyTestResponse,
-    AuditEvent,
-    AuditEventsResponse,
     BulkRevokeRequest,
     BulkRevokeResponse,
     BulkRevokeResult,
+    CreatedWebhook,
+    CreateExportRequest,
+    CreateExportResponse,
     CreateOrganizationRequest,
+    CreateProjectRequest,
     CreateWebhookRequest,
     CurrentPlanResponse,
+    ExportDownloadUrl,
+    ExportFilters,
+    ExportJob,
+    ExportJobListResponse,
     Integration,
     JsonObject,
     LoginRequest,
@@ -52,17 +58,18 @@ from .control_plane_types import (
     LoginSession,
     LoginTokens,
     OrganizationMembership,
-    OrganizationSettings,
     Project,
+    RenameProjectRequest,
     ReplayWebhookDeliveriesRequest,
     Session,
     SessionsResponse,
-    TeamMember,
     TestWebhookRequest,
     UpdateWebhookRequest,
     Webhook,
     WebhookDeliveriesResponse,
     WebhookDelivery,
+    WebhookEventTypesResponse,
+    WebhookHealth,
     WebhookReplayResponse,
     WebhooksResponse,
     WebhookTestResponse,
@@ -108,12 +115,14 @@ __all__ += [
     "ControlPlaneClient", "AsyncControlPlaneClient", "JsonObject",
     "BulkRevokeRequest", "BulkRevokeResult", "BulkRevokeResponse",
     "ApiKeyTestResponse", "LoginRequest", "LoginTokens", "LoginSession",
-    "LoginResponse", "CurrentPlanResponse", "TeamMember", "Session",
-    "SessionsResponse", "AuditEvent", "AuditEventsResponse", "Integration",
-    "CreateOrganizationRequest", "OrganizationMembership",
-    "OrganizationSettings", "Project", "CreateWebhookRequest",
+    "LoginResponse", "CurrentPlanResponse", "Session", "SessionsResponse",
+    "Integration", "CreateOrganizationRequest", "OrganizationMembership",
+    "Project", "CreateProjectRequest",
+    "RenameProjectRequest", "CreateWebhookRequest", "CreatedWebhook",
     "UpdateWebhookRequest", "TestWebhookRequest",
     "ReplayWebhookDeliveriesRequest", "Webhook", "WebhooksResponse",
     "WebhookTestResponse", "WebhookReplayResponse", "WebhookDelivery",
-    "WebhookDeliveriesResponse",
+    "WebhookDeliveriesResponse", "WebhookEventTypesResponse", "WebhookHealth",
+    "ExportFilters", "CreateExportRequest", "ExportJob",
+    "ExportJobListResponse", "CreateExportResponse", "ExportDownloadUrl",
 ]

memorysync-1.5.0/src/memorysync/_version.py

@@ -0,0 +1 @@
+__version__ = "1.5.0"

{memorysync-1.3.0 → memorysync-1.5.0}/src/memorysync/connections.py

@@ -38,7 +38,7 @@ shapes (memories, history, feedback, ontology).
 
 from __future__ import annotations
 
-from typing import Any, Callable, Dict, Optional, Sequence
+from typing import Any, Callable, Dict, Mapping, Optional, Sequence
 from urllib.parse import quote
 
 _V2 = "/api/v2/integrations"
@@ -58,6 +58,20 @@ def _seg(value: Any) -> str:
     return quote(str(value), safe="")
 
 
+def _as_item(value: Any, key: str) -> Dict[str, Any]:
+    """Normalize one selection entry into the object the API expects.
+
+    Two of the approval endpoints take a list of objects rather than a list of
+    ids — Slack channels carry an optional name and type, S3 prefixes carry an
+    optional bucket and label. Callers almost always have just the id, so both
+    forms are accepted here and widened to the object form, rather than making
+    every caller write ``{"id": channel_id}`` and making the simple case ugly.
+    """
+    if isinstance(value, Mapping):
+        return dict(value)
+    return {key: value}
+
+
 class _Namespace:
     """Holds the bound request function. Subclasses add methods."""
 
@@ -97,11 +111,22 @@ class SlackNamespace(_Namespace):
             "GET", f"{_V2}/connections/{_seg(connection_id)}/slack/channels"
         )
 
-    def add_channels(self, connection_id: str, channel_ids: Sequence[str]) -> Any:
-        """Select channels for syncing."""
+    def add_channels(self, connection_id: str, channels: Sequence[Any]) -> Any:
+        """Select channels for syncing.
+
+        Accepts bare channel ids, which is the common case::
+
+            client.connections.slack.add_channels("c1", ["C0123", "C0456"])
+
+        or dicts when you want to carry the name and type across so the server
+        does not have to look them up again::
+
+            add_channels("c1", [{"id": "C0123", "name": "support",
+                                 "is_private": False}])
+        """
         return self._request(
             "POST", f"{_V2}/connections/{_seg(connection_id)}/slack/channels",
-            json={"channel_ids": list(channel_ids)},
+            json={"channels": [_as_item(c, "id") for c in channels]},
         )
 
     def remove_channel(self, connection_id: str, channel_id: str) -> Any:
@@ -195,18 +220,47 @@ class S3Namespace(_Namespace):
             "GET", f"{_V2}/connections/{_seg(connection_id)}/s3/prefixes"
         )
 
-    def add_prefixes(self, connection_id: str, prefixes: Sequence[str]) -> Any:
-        """Select prefixes for syncing."""
+    def add_prefixes(self, connection_id: str, prefixes: Sequence[Any]) -> Any:
+        """Select prefixes for syncing.
+
+        Accepts bare prefixes, or dicts carrying ``bucket`` and ``label``::
+
+            add_prefixes("c1", ["handbook/", "policies/"])
+            add_prefixes("c1", [{"prefix": "handbook/", "label": "Handbook"}])
+
+        An empty string means the bucket root. The bucket defaults to the one the
+        connection's credentials were validated against, and the API rejects any
+        other bucket rather than indexing one nobody proved access to.
+        """
         return self._request(
             "POST", f"{_V2}/connections/{_seg(connection_id)}/s3/prefixes",
-            json={"prefixes": list(prefixes)},
-        )
-
-    def remove_prefixes(self, connection_id: str, prefixes: Sequence[str]) -> Any:
-        """Stop syncing the given prefixes."""
+            json={"prefixes": [_as_item(p, "prefix") for p in prefixes]},
+        )
+
+    def remove_prefix(
+        self,
+        connection_id: str,
+        prefix: str = "",
+        *,
+        bucket: Optional[str] = None,
+        purge: bool = False,
+    ) -> Any:
+        """Revoke one prefix approval, optionally purging what it produced.
+
+        The prefix travels as a query parameter, not in the body and not as a path
+        segment: prefixes contain slashes, which a path segment cannot carry
+        unambiguously, and this endpoint reads no body at all.
+
+        Pass ``purge=True`` to also delete the memories already derived from the
+        prefix. The default leaves them in place, so revoking an approval does not
+        silently destroy knowledge.
+        """
+        params: Dict[str, Any] = {"prefix": prefix, "purge": purge}
+        if bucket is not None:
+            params["bucket"] = bucket
         return self._request(
             "DELETE", f"{_V2}/connections/{_seg(connection_id)}/s3/prefixes",
-            json={"prefixes": list(prefixes)},
+            params=params,
         )
 
     def exclusion_policy(self, connection_id: str) -> Any:
@@ -286,10 +340,15 @@ class GranolaNamespace(_Namespace):
         )
 
     def relink_identity(self, connection_id: str, **body: Any) -> Any:
-        """Move an existing mapping to a different end user."""
+        """Re-run identity matching for this connection.
+
+        Takes no arguments: the route reads no body and re-matches the whole
+        roster. ``**body`` is kept only so a forward-compatible field can be
+        passed once the route grows one.
+        """
         return self._request(
             "POST", f"{_V2}/connections/{_seg(connection_id)}/granola/identities/relink",
-            json=body,
+            json=body or None,
         )
 
     def settings(self, connection_id: str) -> Any:
@@ -321,7 +380,7 @@ class ConnectionOAuthNamespace(_Namespace):
         platform back. Poll :meth:`status` to find out how it went — the callback
         does not come to your backend.
         """
-        payload = {"provider": provider}
+        payload = {"provider_id": provider}
         payload.update(body)
         return self._request("POST", f"{_V2}/oauth/initiate", json=payload)
 
@@ -361,14 +420,18 @@ class ConnectionsNamespace(_Namespace):
         return self._request("GET", f"{_V2}/connections/{_seg(connection_id)}")
 
     def create_with_api_key(self, provider: str, api_key: str, **body: Any) -> Any:
-        """Connect a provider that authenticates with an API key or bot token."""
-        payload: Dict[str, Any] = {"provider": provider, "api_key": api_key}
+        """Connect a provider that authenticates with an API key or bot token.
+
+        The wire field is ``provider_id``; the argument is named ``provider``
+        because that is what the rest of this namespace calls it.
+        """
+        payload: Dict[str, Any] = {"provider_id": provider, "api_key": api_key}
         payload.update(body)
         return self._request("POST", f"{_V2}/connections/api-key", json=payload)
 
     def create_with_credentials(self, provider: str, credentials: Dict[str, Any], **body: Any) -> Any:
         """Connect a provider that needs a credential bundle, such as S3 keys."""
-        payload: Dict[str, Any] = {"provider": provider, "credentials": credentials}
+        payload: Dict[str, Any] = {"provider_id": provider, "credentials": credentials}
         payload.update(body)
         return self._request("POST", f"{_V2}/connections/credentials", json=payload)
 

{memorysync-1.3.0 → memorysync-1.5.0}/src/memorysync/control_plane.py

@@ -6,16 +6,17 @@ import re
 from datetime import datetime, timezone
 from email.utils import parsedate_to_datetime
 from typing import Any, Dict, List, Mapping, Optional, Sequence, TypeVar, cast
-from urllib.parse import urlparse
+from urllib.parse import quote, urlparse
 
 import httpx
 
 from ._version import __version__
 from .control_plane_types import (
-    ApiKeyTestResponse, AuditEventsResponse, BulkRevokeResponse,
-    CurrentPlanResponse, Integration, LoginResponse, OrganizationMembership,
-    OrganizationSettings, Project, Session, SessionsResponse, TeamMember,
-    Webhook, WebhookDeliveriesResponse, WebhookReplayResponse,
+    ApiKeyTestResponse, BulkRevokeResponse, CreatedWebhook, CreateExportResponse,
+    CurrentPlanResponse, ExportDownloadUrl, ExportJob, ExportJobListResponse,
+    Integration, LoginResponse, OrganizationMembership, Project, Session,
+    SessionsResponse, Webhook, WebhookDeliveriesResponse, WebhookDelivery,
+    WebhookEventTypesResponse, WebhookHealth, WebhookReplayResponse,
     WebhooksResponse, WebhookTestResponse,
 )
 from .errors import (
@@ -200,6 +201,93 @@ def _validate_webhook(name: str, url: str, events: Sequence[str]) -> None:
     _string_sequence(events, "events")
 
 
+def _project_name(value: str) -> str:
+    _required_text(value, "name")
+    if len(value) > 200:
+        raise ValidationError("name may contain at most 200 characters")
+    return value
+
+
+def _webhook_retry_config(value: Optional[Mapping[str, Any]]) -> Optional[Dict[str, Any]]:
+    if value is None:
+        return None
+    if not isinstance(value, Mapping):
+        raise ValidationError("retry_config must be a mapping")
+    allowed = {
+        "enabled", "max_retries", "initial_delay_seconds", "max_delay_seconds",
+        "backoff_multiplier", "retry_status_codes",
+    }
+    unknown = set(value) - allowed
+    if unknown:
+        raise ValidationError(f"retry_config contains unsupported fields: {sorted(unknown)}")
+    result = dict(value)
+    if "enabled" in result and not isinstance(result["enabled"], bool):
+        raise ValidationError("retry_config.enabled must be a boolean")
+    for key, minimum, maximum in (
+        ("max_retries", 1, 10), ("initial_delay_seconds", 1, 60),
+        ("max_delay_seconds", 60, 86400),
+    ):
+        if key in result:
+            _bounded(result[key], f"retry_config.{key}", minimum, maximum)
+    if "backoff_multiplier" in result:
+        multiplier = result["backoff_multiplier"]
+        if (not isinstance(multiplier, (int, float)) or isinstance(multiplier, bool)
+                or not 1.0 <= multiplier <= 5.0):
+            raise ValidationError("retry_config.backoff_multiplier must be between 1 and 5")
+    if "retry_status_codes" in result:
+        _string_sequence(result["retry_status_codes"], "retry_config.retry_status_codes")
+    return result
+
+
+def _webhook_signature_config(value: Optional[Mapping[str, Any]]) -> Optional[Dict[str, Any]]:
+    if value is None:
+        return None
+    if not isinstance(value, Mapping):
+        raise ValidationError("signature_config must be a mapping")
+    allowed = {"algorithm", "header_name", "timestamp_header", "tolerance_seconds"}
+    unknown = set(value) - allowed
+    if unknown:
+        raise ValidationError(f"signature_config contains unsupported fields: {sorted(unknown)}")
+    result = dict(value)
+    if "algorithm" in result and result["algorithm"] not in ("hmac-sha256", "hmac-sha512"):
+        raise ValidationError("signature_config.algorithm must be 'hmac-sha256' or 'hmac-sha512'")
+    for key in ("header_name", "timestamp_header"):
+        if key in result:
+            _required_text(result[key], f"signature_config.{key}")
+            if len(result[key]) > 64:
+                raise ValidationError(f"signature_config.{key} may contain at most 64 characters")
+    if "tolerance_seconds" in result:
+        _bounded(result["tolerance_seconds"], "signature_config.tolerance_seconds", 60, 3600)
+    return result
+
+
+def _path_segment(value: str, name: str) -> str:
+    """Validate and percent-encode an opaque identifier as one URL segment."""
+    return quote(_required_text(value, name), safe="")
+
+
+def _export_job_id(value: str) -> str:
+    _required_text(value, "job_id")
+    if not 8 <= len(value) <= 64:
+        raise ValidationError("job_id must contain between 8 and 64 characters")
+    return quote(value, safe="")
+
+
+def _export_filters(value: Optional[Mapping[str, Any]]) -> Optional[Dict[str, Any]]:
+    if value is None:
+        return None
+    if not isinstance(value, Mapping):
+        raise ValidationError("filters must be a mapping")
+    allowed = {
+        "q", "user_id", "is_summary", "tier", "source", "time_range",
+        "date_from", "date_to", "include_soft_deleted",
+    }
+    unknown = set(value) - allowed
+    if unknown:
+        raise ValidationError(f"filters contains unsupported fields: {sorted(unknown)}")
+    return dict(value)
+
+
 class ControlPlaneClient(_ControlPlaneBase):
     """Synchronous bearer client for dashboard/control-plane routes."""
 
@@ -262,59 +350,12 @@ class ControlPlaneClient(_ControlPlaneBase):
     def get_current_plan(self) -> CurrentPlanResponse:
         return cast(CurrentPlanResponse, self._request("GET", "/org/billing/current-plan"))
 
-    def list_team_members(self) -> List[TeamMember]:
-        return cast(List[TeamMember], self._request("GET", "/admin/team/members"))
-
-    def suspend_team_member(self, member_id: int) -> TeamMember:
-        path = f"/admin/team/members/{_positive_id(member_id, 'member_id')}"
-        return cast(TeamMember, self._request("PATCH", path, json={"status": "suspended"}))
-
-    def remove_team_member(self, member_id: int) -> None:
-        path = f"/admin/team/members/{_positive_id(member_id, 'member_id')}"
-        self._request("DELETE", path)
-
     def list_sessions(self) -> SessionsResponse:
         return cast(SessionsResponse, self._request("GET", "/auth/sessions"))
 
     def revoke_session(self, session_id: int) -> None:
         self._request("POST", f"/auth/sessions/{_positive_id(session_id, 'session_id')}/revoke")
 
-
-    def list_audit_events(
-        self, *, limit: Optional[int] = None, cursor: Optional[int] = None,
-        skip: Optional[int] = None, sort_direction: Optional[str] = None,
-        tenant_id: Optional[str] = None, actor: Optional[str] = None,
-        actor_email: Optional[str] = None, ip: Optional[str] = None,
-        action: Optional[str] = None, resource_type: Optional[str] = None,
-        resource_id: Optional[str] = None, severity: Optional[str] = None,
-        category: Optional[str] = None, start: Optional[str] = None,
-        end: Optional[str] = None, success: Optional[bool] = None,
-        source: Optional[str] = None, ingest_method: Optional[str] = None,
-        search: Optional[str] = None, include_stats: Optional[bool] = None,
-    ) -> AuditEventsResponse:
-        if limit is not None:
-            _bounded(limit, "limit", 1, 200)
-        if cursor is not None and cursor < 0:
-            raise ValidationError("cursor must be non-negative")
-        if skip is not None and skip < 0:
-            raise ValidationError("skip must be non-negative")
-        if sort_direction not in (None, "asc", "desc"):
-            raise ValidationError("sort_direction must be 'asc' or 'desc'")
-        params = _body(limit=limit, cursor=cursor, skip=skip, sort=sort_direction,
-                       tenant_id=tenant_id, actor=actor, actor_email=actor_email,
-                       ip=ip, action=action, resource_type=resource_type,
-                       resource_id=resource_id, severity=severity, category=category,
-                       start=start, end=end, success=success, source=source,
-                       ingest_method=ingest_method, search=search,
-                       include_stats=include_stats)
-        raw = self._request("GET", "/admin/audit-logs", params=params)
-        return cast(AuditEventsResponse, {
-            "events": raw.get("logs", []),
-            "next_cursor": raw.get("next_cursor"),
-            "stats": raw.get("stats"),
-            "sort": raw.get("sort", sort_direction or "desc"),
-        })
-
     def list_integrations(self, *, category: Optional[str] = None) -> List[Integration]:
         if category is not None:
             _required_text(category, "category")
@@ -329,41 +370,63 @@ class ControlPlaneClient(_ControlPlaneBase):
     def list_organizations(self) -> List[OrganizationMembership]:
         return cast(List[OrganizationMembership], self._request("GET", "/organizations"))
 
-    def list_organization_members(self) -> List[TeamMember]:
-        return self.list_team_members()
-
-    def get_organization_settings(self, *, tenant_id: Optional[str] = None) -> OrganizationSettings:
-        if tenant_id is not None:
-            _required_text(tenant_id, "tenant_id")
-        return cast(OrganizationSettings, self._request("GET", "/admin/tenant-settings", params=_body(tenant_id=tenant_id)))
-
     def list_projects(self) -> List[Project]:
         return cast(List[Project], self._request("GET", "/org/projects"))
 
+    def create_project(self, name: str) -> Project:
+        return cast(Project, self._request("POST", "/org/projects", json={"name": _project_name(name)}))
+
+    def rename_project(self, project_id: str, name: str) -> Project:
+        path = f"/org/projects/{_path_segment(project_id, 'project_id')}"
+        return cast(Project, self._request("PATCH", path, json={"name": _project_name(name)}))
+
+    def archive_project(self, project_id: str) -> Project:
+        path = f"/org/projects/{_path_segment(project_id, 'project_id')}/archive"
+        return cast(Project, self._request("POST", path))
+
+    def unarchive_project(self, project_id: str) -> Project:
+        path = f"/org/projects/{_path_segment(project_id, 'project_id')}/unarchive"
+        return cast(Project, self._request("POST", path))
+
+    def delete_project(self, project_id: str) -> None:
+        self._request("DELETE", f"/org/projects/{_path_segment(project_id, 'project_id')}")
+
     def create_webhook(
         self, name: str, url: str, events: Sequence[str], *,
-        description: Optional[str] = None, retry_config: Optional[Dict[str, Any]] = None,
-        signature_config: Optional[Dict[str, Any]] = None,
+        description: Optional[str] = None, retry_config: Optional[Mapping[str, Any]] = None,
+        signature_config: Optional[Mapping[str, Any]] = None,
         project_id: Optional[str] = None,
-    ) -> Webhook:
+    ) -> CreatedWebhook:
         _validate_webhook(name, url, events)
         if description is not None and len(description) > 500:
             raise ValidationError("description may contain at most 500 characters")
-        data = _body(name=name, url=url, events=list(events), description=description,
-                     retry_config=retry_config, signature_config=signature_config,
-                     project_id=project_id)
-        return cast(Webhook, self._request("POST", "/org/webhooks", json=data, project_id=_project_override(project_id)))
+        data = _body(
+            name=name, url=url, events=list(events), description=description,
+            retry_config=_webhook_retry_config(retry_config),
+            signature_config=_webhook_signature_config(signature_config),
+            project_id=project_id,
+        )
+        return cast(CreatedWebhook, self._request("POST", "/org/webhooks", json=data, project_id=_project_override(project_id)))
 
     def list_webhooks(self, *, project_id: Optional[str] = None) -> WebhooksResponse:
         return cast(WebhooksResponse, self._request("GET", "/org/webhooks", project_id=_project_override(project_id)))
 
+    def get_webhook(self, endpoint_id: int, *, project_id: Optional[str] = None) -> Webhook:
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}"
+        return cast(Webhook, self._request("GET", path, project_id=_project_override(project_id)))
+
+    def get_webhook_event_types(self, *, project_id: Optional[str] = None) -> WebhookEventTypesResponse:
+        return cast(WebhookEventTypesResponse, self._request("GET", "/org/webhooks/event-types", project_id=_project_override(project_id)))
+
+    def get_webhook_health(self, *, project_id: Optional[str] = None) -> WebhookHealth:
+        return cast(WebhookHealth, self._request("GET", "/org/webhooks/health", project_id=_project_override(project_id)))
 
     def update_webhook(
         self, endpoint_id: int, *, name: Optional[str] = None,
         url: Optional[str] = None, description: Optional[str] = None,
         events: Optional[Sequence[str]] = None,
-        retry_config: Optional[Dict[str, Any]] = None,
-        signature_config: Optional[Dict[str, Any]] = None,
+        retry_config: Optional[Mapping[str, Any]] = None,
+        signature_config: Optional[Mapping[str, Any]] = None,
         project_id: Optional[str] = None,
     ) -> Webhook:
         if name is not None:
@@ -376,9 +439,12 @@ class ControlPlaneClient(_ControlPlaneBase):
             raise ValidationError("description may contain at most 500 characters")
         if events is not None:
             _string_sequence(events, "events")
-        data = _body(name=name, url=url, description=description,
-                     events=list(events) if events is not None else None,
-                     retry_config=retry_config, signature_config=signature_config)
+        data = _body(
+            name=name, url=url, description=description,
+            events=list(events) if events is not None else None,
+            retry_config=_webhook_retry_config(retry_config),
+            signature_config=_webhook_signature_config(signature_config),
+        )
         if not data:
             raise ValidationError("update_webhook requires at least one editable field")
         path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}"
@@ -388,6 +454,18 @@ class ControlPlaneClient(_ControlPlaneBase):
         path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}"
         self._request("DELETE", path, project_id=_project_override(project_id))
 
+    def pause_webhook(self, endpoint_id: int, *, project_id: Optional[str] = None) -> Webhook:
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}/pause"
+        return cast(Webhook, self._request("POST", path, project_id=_project_override(project_id)))
+
+    def resume_webhook(self, endpoint_id: int, *, project_id: Optional[str] = None) -> Webhook:
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}/resume"
+        return cast(Webhook, self._request("POST", path, project_id=_project_override(project_id)))
+
+    def rotate_webhook_secret(self, endpoint_id: int, *, project_id: Optional[str] = None) -> CreatedWebhook:
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}/rotate-secret"
+        return cast(CreatedWebhook, self._request("POST", path, project_id=_project_override(project_id)))
+
     def test_webhook(
         self, endpoint_id: int, *, event_type: str = "memory.created",
         project_id: Optional[str] = None,
@@ -408,8 +486,14 @@ class ControlPlaneClient(_ControlPlaneBase):
         data = {"since_minutes": since_minutes, "statuses": list(statuses), "limit": limit}
         return cast(WebhookReplayResponse, self._request("POST", path, json=data, project_id=_project_override(project_id)))
 
+    def get_latest_webhook_delivery(
+        self, endpoint_id: int, *, project_id: Optional[str] = None,
+    ) -> Optional[WebhookDelivery]:
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}/deliveries/latest"
+        return cast(Optional[WebhookDelivery], self._request("GET", path, project_id=_project_override(project_id)))
+
     def list_webhook_deliveries(
-        self, endpoint_id: int, *, page: int = 1, page_size: int = 25,
+        self, endpoint_id: int, *, page: int = 1, page_size: int = 20,
         status: Optional[str] = None, project_id: Optional[str] = None,
     ) -> WebhookDeliveriesResponse:
         _positive_id(page, "page")
@@ -420,6 +504,60 @@ class ControlPlaneClient(_ControlPlaneBase):
         params = _body(page=page, page_size=page_size, status_filter=status)
         return cast(WebhookDeliveriesResponse, self._request("GET", path, params=params, project_id=_project_override(project_id)))
 
+    def list_recent_webhook_deliveries(
+        self, *, page: int = 1, page_size: int = 20,
+        endpoint_id: Optional[int] = None, status: Optional[str] = None,
+        project_id: Optional[str] = None,
+    ) -> WebhookDeliveriesResponse:
+        _positive_id(page, "page")
+        _bounded(page_size, "page_size", 1, 100)
+        if endpoint_id is not None:
+            _positive_id(endpoint_id, "endpoint_id")
+        if status is not None:
+            _required_text(status, "status")
+        params = _body(page=page, page_size=page_size, endpoint_id=endpoint_id, status_filter=status)
+        return cast(WebhookDeliveriesResponse, self._request("GET", "/org/webhooks/deliveries/recent", params=params, project_id=_project_override(project_id)))
+
+    def get_webhook_delivery(self, delivery_id: int, *, project_id: Optional[str] = None) -> WebhookDelivery:
+        path = f"/org/webhooks/deliveries/{_positive_id(delivery_id, 'delivery_id')}"
+        return cast(WebhookDelivery, self._request("GET", path, project_id=_project_override(project_id)))
+
+    def retry_webhook_delivery(self, delivery_id: int, *, project_id: Optional[str] = None) -> WebhookDelivery:
+        path = f"/org/webhooks/deliveries/{_positive_id(delivery_id, 'delivery_id')}/retry"
+        return cast(WebhookDelivery, self._request("POST", path, project_id=_project_override(project_id)))
+
+    def create_export(
+        self, *, format: str = "csv", scope: str = "filtered",
+        filters: Optional[Mapping[str, Any]] = None,
+        project_id: Optional[str] = None,
+    ) -> CreateExportResponse:
+        if format not in ("csv", "jsonl"):
+            raise ValidationError("format must be 'csv' or 'jsonl'")
+        if scope not in ("filtered", "all", "date_range"):
+            raise ValidationError("scope must be 'filtered', 'all', or 'date_range'")
+        data = _body(format=format, scope=scope, filters=_export_filters(filters))
+        return cast(CreateExportResponse, self._request("POST", "/exports", json=data, project_id=_project_override(project_id)))
+
+    def list_exports(self, *, limit: int = 20, project_id: Optional[str] = None) -> ExportJobListResponse:
+        _bounded(limit, "limit", 1, 100)
+        return cast(ExportJobListResponse, self._request("GET", "/exports", params={"limit": limit}, project_id=_project_override(project_id)))
+
+    def get_export(self, job_id: str, *, project_id: Optional[str] = None) -> ExportJob:
+        path = f"/exports/{_export_job_id(job_id)}"
+        return cast(ExportJob, self._request("GET", path, project_id=_project_override(project_id)))
+
+    def cancel_export(self, job_id: str, *, project_id: Optional[str] = None) -> ExportJob:
+        path = f"/exports/{_export_job_id(job_id)}/cancel"
+        return cast(ExportJob, self._request("POST", path, project_id=_project_override(project_id)))
+
+    def retry_export(self, job_id: str, *, project_id: Optional[str] = None) -> CreateExportResponse:
+        path = f"/exports/{_export_job_id(job_id)}/retry"
+        return cast(CreateExportResponse, self._request("POST", path, project_id=_project_override(project_id)))
+
+    def get_export_download_url(self, job_id: str, *, project_id: Optional[str] = None) -> ExportDownloadUrl:
+        path = f"/exports/{_export_job_id(job_id)}/download-url"
+        return cast(ExportDownloadUrl, self._request("GET", path, project_id=_project_override(project_id)))
+
 
 class AsyncControlPlaneClient(_ControlPlaneBase):
     """Async-native bearer client for dashboard/control-plane routes."""
@@ -482,58 +620,12 @@ class AsyncControlPlaneClient(_ControlPlaneBase):
     async def get_current_plan(self) -> CurrentPlanResponse:
         return cast(CurrentPlanResponse, await self._request("GET", "/org/billing/current-plan"))
 
-    async def list_team_members(self) -> List[TeamMember]:
-        return cast(List[TeamMember], await self._request("GET", "/admin/team/members"))
-
-    async def suspend_team_member(self, member_id: int) -> TeamMember:
-        path = f"/admin/team/members/{_positive_id(member_id, 'member_id')}"
-        return cast(TeamMember, await self._request("PATCH", path, json={"status": "suspended"}))
-
-    async def remove_team_member(self, member_id: int) -> None:
-        await self._request("DELETE", f"/admin/team/members/{_positive_id(member_id, 'member_id')}")
-
     async def list_sessions(self) -> SessionsResponse:
         return cast(SessionsResponse, await self._request("GET", "/auth/sessions"))
 
     async def revoke_session(self, session_id: int) -> None:
         await self._request("POST", f"/auth/sessions/{_positive_id(session_id, 'session_id')}/revoke")
 
-
-    async def list_audit_events(
-        self, *, limit: Optional[int] = None, cursor: Optional[int] = None,
-        skip: Optional[int] = None, sort_direction: Optional[str] = None,
-        tenant_id: Optional[str] = None, actor: Optional[str] = None,
-        actor_email: Optional[str] = None, ip: Optional[str] = None,
-        action: Optional[str] = None, resource_type: Optional[str] = None,
-        resource_id: Optional[str] = None, severity: Optional[str] = None,
-        category: Optional[str] = None, start: Optional[str] = None,
-        end: Optional[str] = None, success: Optional[bool] = None,
-        source: Optional[str] = None, ingest_method: Optional[str] = None,
-        search: Optional[str] = None, include_stats: Optional[bool] = None,
-    ) -> AuditEventsResponse:
-        if limit is not None:
-            _bounded(limit, "limit", 1, 200)
-        if cursor is not None and cursor < 0:
-            raise ValidationError("cursor must be non-negative")
-        if skip is not None and skip < 0:
-            raise ValidationError("skip must be non-negative")
-        if sort_direction not in (None, "asc", "desc"):
-            raise ValidationError("sort_direction must be 'asc' or 'desc'")
-        params = _body(limit=limit, cursor=cursor, skip=skip, sort=sort_direction,
-                       tenant_id=tenant_id, actor=actor, actor_email=actor_email,
-                       ip=ip, action=action, resource_type=resource_type,
-                       resource_id=resource_id, severity=severity, category=category,
-                       start=start, end=end, success=success, source=source,
-                       ingest_method=ingest_method, search=search,
-                       include_stats=include_stats)
-        raw = await self._request("GET", "/admin/audit-logs", params=params)
-        return cast(AuditEventsResponse, {
-            "events": raw.get("logs", []),
-            "next_cursor": raw.get("next_cursor"),
-            "stats": raw.get("stats"),
-            "sort": raw.get("sort", sort_direction or "desc"),
-        })
-
     async def list_integrations(self, *, category: Optional[str] = None) -> List[Integration]:
         if category is not None:
             _required_text(category, "category")
@@ -550,43 +642,67 @@ class AsyncControlPlaneClient(_ControlPlaneBase):
     async def list_organizations(self) -> List[OrganizationMembership]:
         return cast(List[OrganizationMembership], await self._request("GET", "/organizations"))
 
-    async def list_organization_members(self) -> List[TeamMember]:
-        return await self.list_team_members()
-
-    async def get_organization_settings(self, *, tenant_id: Optional[str] = None) -> OrganizationSettings:
-        if tenant_id is not None:
-            _required_text(tenant_id, "tenant_id")
-        raw = await self._request("GET", "/admin/tenant-settings", params=_body(tenant_id=tenant_id))
-        return cast(OrganizationSettings, raw)
-
     async def list_projects(self) -> List[Project]:
         return cast(List[Project], await self._request("GET", "/org/projects"))
 
+    async def create_project(self, name: str) -> Project:
+        raw = await self._request("POST", "/org/projects", json={"name": _project_name(name)})
+        return cast(Project, raw)
+
+    async def rename_project(self, project_id: str, name: str) -> Project:
+        path = f"/org/projects/{_path_segment(project_id, 'project_id')}"
+        return cast(Project, await self._request("PATCH", path, json={"name": _project_name(name)}))
+
+    async def archive_project(self, project_id: str) -> Project:
+        path = f"/org/projects/{_path_segment(project_id, 'project_id')}/archive"
+        return cast(Project, await self._request("POST", path))
+
+    async def unarchive_project(self, project_id: str) -> Project:
+        path = f"/org/projects/{_path_segment(project_id, 'project_id')}/unarchive"
+        return cast(Project, await self._request("POST", path))
+
+    async def delete_project(self, project_id: str) -> None:
+        await self._request("DELETE", f"/org/projects/{_path_segment(project_id, 'project_id')}")
+
     async def create_webhook(
         self, name: str, url: str, events: Sequence[str], *,
-        description: Optional[str] = None, retry_config: Optional[Dict[str, Any]] = None,
-        signature_config: Optional[Dict[str, Any]] = None,
+        description: Optional[str] = None, retry_config: Optional[Mapping[str, Any]] = None,
+        signature_config: Optional[Mapping[str, Any]] = None,
         project_id: Optional[str] = None,
-    ) -> Webhook:
+    ) -> CreatedWebhook:
         _validate_webhook(name, url, events)
         if description is not None and len(description) > 500:
             raise ValidationError("description may contain at most 500 characters")
-        data = _body(name=name, url=url, events=list(events), description=description,
-                     retry_config=retry_config, signature_config=signature_config,
-                     project_id=project_id)
+        data = _body(
+            name=name, url=url, events=list(events), description=description,
+            retry_config=_webhook_retry_config(retry_config),
+            signature_config=_webhook_signature_config(signature_config),
+            project_id=project_id,
+        )
         raw = await self._request("POST", "/org/webhooks", json=data, project_id=_project_override(project_id))
-        return cast(Webhook, raw)
+        return cast(CreatedWebhook, raw)
 
     async def list_webhooks(self, *, project_id: Optional[str] = None) -> WebhooksResponse:
         return cast(WebhooksResponse, await self._request("GET", "/org/webhooks", project_id=_project_override(project_id)))
 
+    async def get_webhook(self, endpoint_id: int, *, project_id: Optional[str] = None) -> Webhook:
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}"
+        return cast(Webhook, await self._request("GET", path, project_id=_project_override(project_id)))
+
+    async def get_webhook_event_types(self, *, project_id: Optional[str] = None) -> WebhookEventTypesResponse:
+        raw = await self._request("GET", "/org/webhooks/event-types", project_id=_project_override(project_id))
+        return cast(WebhookEventTypesResponse, raw)
+
+    async def get_webhook_health(self, *, project_id: Optional[str] = None) -> WebhookHealth:
+        raw = await self._request("GET", "/org/webhooks/health", project_id=_project_override(project_id))
+        return cast(WebhookHealth, raw)
 
     async def update_webhook(
         self, endpoint_id: int, *, name: Optional[str] = None,
         url: Optional[str] = None, description: Optional[str] = None,
         events: Optional[Sequence[str]] = None,
-        retry_config: Optional[Dict[str, Any]] = None,
-        signature_config: Optional[Dict[str, Any]] = None,
+        retry_config: Optional[Mapping[str, Any]] = None,
+        signature_config: Optional[Mapping[str, Any]] = None,
         project_id: Optional[str] = None,
     ) -> Webhook:
         if name is not None:
@@ -599,19 +715,33 @@ class AsyncControlPlaneClient(_ControlPlaneBase):
             raise ValidationError("description may contain at most 500 characters")
         if events is not None:
             _string_sequence(events, "events")
-        data = _body(name=name, url=url, description=description,
-                     events=list(events) if events is not None else None,
-                     retry_config=retry_config, signature_config=signature_config)
+        data = _body(
+            name=name, url=url, description=description,
+            events=list(events) if events is not None else None,
+            retry_config=_webhook_retry_config(retry_config),
+            signature_config=_webhook_signature_config(signature_config),
+        )
         if not data:
             raise ValidationError("update_webhook requires at least one editable field")
         path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}"
-        raw = await self._request("PATCH", path, json=data, project_id=_project_override(project_id))
-        return cast(Webhook, raw)
+        return cast(Webhook, await self._request("PATCH", path, json=data, project_id=_project_override(project_id)))
 
     async def delete_webhook(self, endpoint_id: int, *, project_id: Optional[str] = None) -> None:
         path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}"
         await self._request("DELETE", path, project_id=_project_override(project_id))
 
+    async def pause_webhook(self, endpoint_id: int, *, project_id: Optional[str] = None) -> Webhook:
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}/pause"
+        return cast(Webhook, await self._request("POST", path, project_id=_project_override(project_id)))
+
+    async def resume_webhook(self, endpoint_id: int, *, project_id: Optional[str] = None) -> Webhook:
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}/resume"
+        return cast(Webhook, await self._request("POST", path, project_id=_project_override(project_id)))
+
+    async def rotate_webhook_secret(self, endpoint_id: int, *, project_id: Optional[str] = None) -> CreatedWebhook:
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}/rotate-secret"
+        return cast(CreatedWebhook, await self._request("POST", path, project_id=_project_override(project_id)))
+
     async def test_webhook(
         self, endpoint_id: int, *, event_type: str = "memory.created",
         project_id: Optional[str] = None,
@@ -634,8 +764,15 @@ class AsyncControlPlaneClient(_ControlPlaneBase):
         raw = await self._request("POST", path, json=data, project_id=_project_override(project_id))
         return cast(WebhookReplayResponse, raw)
 
+    async def get_latest_webhook_delivery(
+        self, endpoint_id: int, *, project_id: Optional[str] = None,
+    ) -> Optional[WebhookDelivery]:
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}/deliveries/latest"
+        raw = await self._request("GET", path, project_id=_project_override(project_id))
+        return cast(Optional[WebhookDelivery], raw)
+
     async def list_webhook_deliveries(
-        self, endpoint_id: int, *, page: int = 1, page_size: int = 25,
+        self, endpoint_id: int, *, page: int = 1, page_size: int = 20,
         status: Optional[str] = None, project_id: Optional[str] = None,
     ) -> WebhookDeliveriesResponse:
         _positive_id(page, "page")
@@ -646,3 +783,59 @@ class AsyncControlPlaneClient(_ControlPlaneBase):
         params = _body(page=page, page_size=page_size, status_filter=status)
         raw = await self._request("GET", path, params=params, project_id=_project_override(project_id))
         return cast(WebhookDeliveriesResponse, raw)
+
+    async def list_recent_webhook_deliveries(
+        self, *, page: int = 1, page_size: int = 20,
+        endpoint_id: Optional[int] = None, status: Optional[str] = None,
+        project_id: Optional[str] = None,
+    ) -> WebhookDeliveriesResponse:
+        _positive_id(page, "page")
+        _bounded(page_size, "page_size", 1, 100)
+        if endpoint_id is not None:
+            _positive_id(endpoint_id, "endpoint_id")
+        if status is not None:
+            _required_text(status, "status")
+        params = _body(page=page, page_size=page_size, endpoint_id=endpoint_id, status_filter=status)
+        raw = await self._request("GET", "/org/webhooks/deliveries/recent", params=params, project_id=_project_override(project_id))
+        return cast(WebhookDeliveriesResponse, raw)
+
+    async def get_webhook_delivery(self, delivery_id: int, *, project_id: Optional[str] = None) -> WebhookDelivery:
+        path = f"/org/webhooks/deliveries/{_positive_id(delivery_id, 'delivery_id')}"
+        return cast(WebhookDelivery, await self._request("GET", path, project_id=_project_override(project_id)))
+
+    async def retry_webhook_delivery(self, delivery_id: int, *, project_id: Optional[str] = None) -> WebhookDelivery:
+        path = f"/org/webhooks/deliveries/{_positive_id(delivery_id, 'delivery_id')}/retry"
+        return cast(WebhookDelivery, await self._request("POST", path, project_id=_project_override(project_id)))
+
+    async def create_export(
+        self, *, format: str = "csv", scope: str = "filtered",
+        filters: Optional[Mapping[str, Any]] = None,
+        project_id: Optional[str] = None,
+    ) -> CreateExportResponse:
+        if format not in ("csv", "jsonl"):
+            raise ValidationError("format must be 'csv' or 'jsonl'")
+        if scope not in ("filtered", "all", "date_range"):
+            raise ValidationError("scope must be 'filtered', 'all', or 'date_range'")
+        data = _body(format=format, scope=scope, filters=_export_filters(filters))
+        raw = await self._request("POST", "/exports", json=data, project_id=_project_override(project_id))
+        return cast(CreateExportResponse, raw)
+
+    async def list_exports(self, *, limit: int = 20, project_id: Optional[str] = None) -> ExportJobListResponse:
+        _bounded(limit, "limit", 1, 100)
+        raw = await self._request("GET", "/exports", params={"limit": limit}, project_id=_project_override(project_id))
+        return cast(ExportJobListResponse, raw)
+
+    async def get_export(self, job_id: str, *, project_id: Optional[str] = None) -> ExportJob:
+        return cast(ExportJob, await self._request("GET", f"/exports/{_export_job_id(job_id)}", project_id=_project_override(project_id)))
+
+    async def cancel_export(self, job_id: str, *, project_id: Optional[str] = None) -> ExportJob:
+        path = f"/exports/{_export_job_id(job_id)}/cancel"
+        return cast(ExportJob, await self._request("POST", path, project_id=_project_override(project_id)))
+
+    async def retry_export(self, job_id: str, *, project_id: Optional[str] = None) -> CreateExportResponse:
+        path = f"/exports/{_export_job_id(job_id)}/retry"
+        return cast(CreateExportResponse, await self._request("POST", path, project_id=_project_override(project_id)))
+
+    async def get_export_download_url(self, job_id: str, *, project_id: Optional[str] = None) -> ExportDownloadUrl:
+        path = f"/exports/{_export_job_id(job_id)}/download-url"
+        return cast(ExportDownloadUrl, await self._request("GET", path, project_id=_project_override(project_id)))

{memorysync-1.3.0 → memorysync-1.5.0}/src/memorysync/control_plane_types.py

@@ -4,6 +4,11 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Optional, TypedDict
 
+try:
+    from typing import NotRequired
+except ImportError:  # Python 3.9 and 3.10
+    from typing_extensions import NotRequired
+
 JsonObject = Dict[str, Any]
 
 
@@ -62,21 +67,6 @@ class CurrentPlanResponse(TypedDict, total=False):
     cancel_at_period_end: bool
 
 
-class TeamMember(TypedDict, total=False):
-    id: str
-    name: str
-    email: str
-    role: str
-    status: str
-    last_active: Optional[str]
-    mfa_enabled: bool
-    auth_method: str
-    login_provider: str
-    devices: int
-    sessions: int
-    is_scim_managed: bool
-
-
 class Session(TypedDict, total=False):
     id: int
     is_current: bool
@@ -93,26 +83,7 @@ class Session(TypedDict, total=False):
 
 class SessionsResponse(TypedDict):
     sessions: List[Session]
-    current_session_id: int
-
-
-class AuditEvent(TypedDict, total=False):
-    id: int
-    event_id: str
-    timestamp: str
-    category: str
-    actor: JsonObject
-    action: str
-    resource: JsonObject
-    severity: str
-    success: bool
-
-
-class AuditEventsResponse(TypedDict, total=False):
-    events: List[AuditEvent]
-    next_cursor: Optional[int]
-    stats: Optional[JsonObject]
-    sort: str
+    current_session_id: Optional[int]
 
 
 class Integration(TypedDict, total=False):
@@ -133,26 +104,6 @@ class OrganizationMembership(TypedDict):
     role: str
 
 
-class OrganizationSettings(TypedDict, total=False):
-    tenant_id: str
-    tenant_name: str
-    tenant_slug: str
-    description: Optional[str]
-    plan: str
-    status: str
-    created_at: str
-    contact_email: str
-    custom_domain: Optional[str]
-    custom_domain_verified: bool
-    logo_url: Optional[str]
-    total_memories: int
-    active_users: int
-    organization_name: str
-    scheduled_deletion_at: Optional[str]
-    mfa_enrolled: bool
-    password_enabled: bool
-
-
 class Project(TypedDict, total=False):
     id: str
     name: str
@@ -173,10 +124,33 @@ class Webhook(TypedDict, total=False):
     events: List[str]
     enabled: bool
     signature_algorithm: str
-    project_id: Optional[str]
-    secret: str
+    signature_header: str
+    timestamp_header: str
+    signature_tolerance: int
+    retry_enabled: bool
+    max_retries: int
+    initial_delay_seconds: int
+    max_delay_seconds: int
+    backoff_multiplier: float
+    retry_status_codes: List[str]
+    total_deliveries: int
+    successful_deliveries: int
+    failed_deliveries: int
+    consecutive_failures: int
     success_rate: float
+    last_triggered_at: Optional[str]
+    last_success_at: Optional[str]
+    last_failure_at: Optional[str]
+    last_error: Optional[str]
+    last_status_code: Optional[int]
+    created_at: str
     updated_at: str
+    created_by_name: Optional[str]
+    project_id: Optional[str]
+
+
+class CreatedWebhook(Webhook):
+    secret: str
 
 
 class WebhooksResponse(TypedDict, total=False):
@@ -212,11 +186,16 @@ class WebhookDelivery(TypedDict, total=False):
     event_type: str
     event_id: str
     status: str
+    payload: JsonObject
     payload_hash: str
+    signature: Optional[str]
     status_code: Optional[int]
+    response_body: Optional[str]
+    error_message: Optional[str]
     latency_ms: Optional[int]
     attempt_number: int
     max_attempts: int
+    next_retry_at: Optional[str]
     created_at: str
     completed_at: Optional[str]
 
@@ -232,6 +211,10 @@ class CreateWebhookRequest(TypedDict):
     name: str
     url: str
     events: List[str]
+    description: NotRequired[Optional[str]]
+    retry_config: NotRequired[JsonObject]
+    signature_config: NotRequired[JsonObject]
+    project_id: NotRequired[str]
 
 
 class UpdateWebhookRequest(TypedDict, total=False):
@@ -265,3 +248,85 @@ class ReplayWebhookDeliveriesRequest(TypedDict):
     since_minutes: int
     statuses: List[str]
     limit: int
+
+
+class CreateProjectRequest(TypedDict):
+    name: str
+
+
+class RenameProjectRequest(TypedDict):
+    name: str
+
+
+class WebhookEventTypesResponse(TypedDict):
+    event_types: List[str]
+    categories: Dict[str, List[str]]
+
+
+class WebhookHealth(TypedDict):
+    active_webhooks: int
+    total_webhooks: int
+    total_deliveries_all_time: int
+    total_deliveries_24h: int
+    success_rate_7d: float
+    failing_endpoints: int
+    pending_retries: int
+    dead_letter_count: int
+
+
+class ExportFilters(TypedDict, total=False):
+    q: str
+    user_id: str
+    is_summary: bool
+    tier: str
+    source: str
+    time_range: str
+    date_from: str
+    date_to: str
+    include_soft_deleted: bool
+
+
+class CreateExportRequest(TypedDict, total=False):
+    format: str
+    scope: str
+    filters: ExportFilters
+
+
+class ExportJob(TypedDict, total=False):
+    id: str
+    project_id: Optional[str]
+    environment: str
+    format: str
+    scope: str
+    filters: JsonObject
+    status: str
+    error_message: Optional[str]
+    retry_count: int
+    total_rows: Optional[int]
+    processed_rows: int
+    progress_percentage: float
+    file_size_bytes: Optional[int]
+    sha256_hash: Optional[str]
+    download_count: int
+    created_at: Optional[str]
+    started_at: Optional[str]
+    completed_at: Optional[str]
+    expires_at: Optional[str]
+    download_url: Optional[str]
+
+
+class ExportJobListResponse(TypedDict):
+    jobs: List[ExportJob]
+    total: int
+
+
+class CreateExportResponse(TypedDict):
+    job: ExportJob
+    estimated_total: Optional[int]
+
+
+class ExportDownloadUrl(TypedDict):
+    download_url: str
+    expires_at: Optional[str]
+    file_size_bytes: Optional[int]
+    filename: str

memorysync-1.3.0/src/memorysync/_version.py

@@ -1 +0,0 @@
-__version__ = "1.3.0"