domani 0.1.0__tar.gz

domani-0.1.0/.gitignore

@@ -0,0 +1,71 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+/dist
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files
+.env
+.env.local
+.env.*.local
+.env.production
+.env.preview
+*.bak
+
+# cli build
+cli/dist
+cli/node_modules
+cli/.next
+public/cli/domainer.js
+public/cli/domainer.js.sha256
+
+# sdk build artifacts (generated SOURCES are committed; these are not)
+sdk/openapi.json
+sdk/ts/dist
+sdk/ts/node_modules
+sdk/ts/package-lock.json
+sdk/python/dist
+sdk/python/build
+sdk/**/__pycache__
+sdk/**/*.egg-info
+
+# generated skill
+public/skill.md
+public/references/
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
+
+/src/generated/prisma
+.env*.local

domani-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: domani
+Version: 0.1.0
+Summary: Official Python SDK for the domani API - domains, email, and identity for AI agents.
+Project-URL: Homepage, https://domani.run
+Project-URL: Repository, https://github.com/gwendall/domani
+Author: domani
+License: MIT
+Keywords: agents,api,domains,domani,email,mcp,sdk
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# domani
+
+Official Python SDK for the [domani](https://domani.run) API - domains, email, and identity for AI agents. Typed, generated from the OpenAPI spec, standard-library only (no dependencies).
+
+## Install
+
+```bash
+pip install domani
+```
+
+Requires Python 3.8+.
+
+## Quickstart
+
+```python
+from domani import Domani, DomaniError
+
+domani = Domani(api_key="domani_sk_...")
+
+# Search availability + pricing
+results = domani.search(query={"q": "myagent.com"})
+
+# Give an agent an inbox
+domani.create_mailbox_by_address(body={"address": "hi@myagent.com"})
+
+# Send mail
+domani.send_email_by_address(
+    "hi@myagent.com",
+    body={"to": "user@example.com", "subject": "Hello", "text": "Sent from my domani mailbox."},
+)
+
+# Errors carry the API's structured code + hint
+try:
+    domani.send_email_by_address("hi@myagent.com", body={"to": "bounced@example.com", "text": "..."})
+except DomaniError as e:
+    print(e.status, e.code, e.hint)  # e.g. 400 RECIPIENTS_SUPPRESSED
+```
+
+## API
+
+`Domani(api_key, base_url=..., timeout=...)` exposes one method per API operation (named after its operationId in snake_case). Path parameters are positional; request bodies (`body=`) and query objects (`query=`) are keyword arguments. Every method returns the parsed JSON response and raises `DomaniError` (`status`, `code`, `hint`, `documentation_url`) on non-2xx.
+
+Full endpoint reference: <https://domani.run/docs> · OpenAPI spec: <https://domani.run/.well-known/openapi.json>
+
+## Generated
+
+`domani/__init__.py` is generated from the domani OpenAPI spec - do not edit it by hand. It is regenerated whenever the API surface changes.
+
+## License
+
+MIT

domani-0.1.0/README.md

@@ -0,0 +1,51 @@
+# domani
+
+Official Python SDK for the [domani](https://domani.run) API - domains, email, and identity for AI agents. Typed, generated from the OpenAPI spec, standard-library only (no dependencies).
+
+## Install
+
+```bash
+pip install domani
+```
+
+Requires Python 3.8+.
+
+## Quickstart
+
+```python
+from domani import Domani, DomaniError
+
+domani = Domani(api_key="domani_sk_...")
+
+# Search availability + pricing
+results = domani.search(query={"q": "myagent.com"})
+
+# Give an agent an inbox
+domani.create_mailbox_by_address(body={"address": "hi@myagent.com"})
+
+# Send mail
+domani.send_email_by_address(
+    "hi@myagent.com",
+    body={"to": "user@example.com", "subject": "Hello", "text": "Sent from my domani mailbox."},
+)
+
+# Errors carry the API's structured code + hint
+try:
+    domani.send_email_by_address("hi@myagent.com", body={"to": "bounced@example.com", "text": "..."})
+except DomaniError as e:
+    print(e.status, e.code, e.hint)  # e.g. 400 RECIPIENTS_SUPPRESSED
+```
+
+## API
+
+`Domani(api_key, base_url=..., timeout=...)` exposes one method per API operation (named after its operationId in snake_case). Path parameters are positional; request bodies (`body=`) and query objects (`query=`) are keyword arguments. Every method returns the parsed JSON response and raises `DomaniError` (`status`, `code`, `hint`, `documentation_url`) on non-2xx.
+
+Full endpoint reference: <https://domani.run/docs> · OpenAPI spec: <https://domani.run/.well-known/openapi.json>
+
+## Generated
+
+`domani/__init__.py` is generated from the domani OpenAPI spec - do not edit it by hand. It is regenerated whenever the API surface changes.
+
+## License
+
+MIT

domani-0.1.0/domani/__init__.py

@@ -0,0 +1,763 @@
+# AUTO-GENERATED from the domani OpenAPI spec by scripts/generate-sdk.ts.
+# Do not edit by hand - re-run `npx tsx scripts/generate-sdk.ts`.
+"""Typed Python client for the domani API."""
+from __future__ import annotations
+
+import json as _json
+import urllib.parse
+import urllib.request
+import urllib.error
+from typing import Any, Dict, List, Literal, Optional, Union
+from urllib.parse import quote
+
+try:  # Python 3.8+
+    from typing import TypedDict
+except ImportError:  # pragma: no cover
+    from typing_extensions import TypedDict  # type: ignore
+
+DEFAULT_BASE_URL = "https://domani.run"
+
+
+class DomaniError(Exception):
+    """Structured API error - mirrors the apiError() shape returned by the API."""
+
+    def __init__(self, status: int, body: Any):
+        self.status = status
+        if isinstance(body, dict):
+            self.code = body.get("code", "ERROR")
+            self.hint = body.get("hint")
+            self.documentation_url = body.get("documentation_url")
+            message = body.get("error") or body.get("message") or f"Request failed with status {status}"
+        else:
+            self.code = "ERROR"
+            self.hint = None
+            self.documentation_url = None
+            message = f"Request failed with status {status}"
+        super().__init__(message)
+
+
+# ─── Types ──────────────────────────────────────────
+
+class Error(TypedDict, total=False):
+    error: str
+    code: Literal["MISSING_API_KEY", "INVALID_API_KEY", "EXPIRED_API_KEY", "MISSING_PARAMETER", "INVALID_DOMAIN", "PAYMENT_REQUIRED", "DOMAIN_UNAVAILABLE", "RATE_LIMIT_EXCEEDED", "USER_EXISTS", "NOT_FOUND", "UNKNOWN_PROVIDER", "UNKNOWN_METHOD", "TARGET_REQUIRED", "INVALID_PARAMETER", "CONTACT_REQUIRED", "INVALID_CONTACT", "INSUFFICIENT_SCOPE", "SCOPE_ESCALATION", "DOMAIN_EXISTS", "DOMAIN_NOT_ACTIVE", "UNSUPPORTED_TLD", "NOT_AVAILABLE", "ALREADY_REGISTERED", "TRANSFER_NOT_ELIGIBLE", "ALREADY_LISTED", "LISTING_SOLD", "SELF_PURCHASE", "DESCRIPTION_TOO_LONG", "DEAL_NOT_FOUND", "INVALID_DEAL_STATE", "EPP_ATTEMPTS_EXCEEDED", "ACTIVE_DEAL_EXISTS"]
+    hint: str
+    fix_command: str
+    documentation_url: str
+    setup_url: str
+    fix_url: str
+    retry_after: int
+
+
+class SearchResult(TypedDict, total=False):
+    available: bool
+    domain: str
+    price: float
+    currency: str
+    error: bool
+    for_sale: Dict[str, Any]
+
+
+class TldInfo(TypedDict, total=False):
+    tld: str
+    registration: float
+    renewal: float
+    transfer: float
+
+
+class DnsRecord(TypedDict, total=False):
+    type: Literal["A", "AAAA", "CNAME", "MX", "TXT", "NS", "SRV", "CAA"]
+    name: str
+    value: str
+    ttl: int
+    priority: int
+
+
+class DomainRecord(TypedDict, total=False):
+    domain: str
+    status: Literal["active", "expired", "pending"]
+    auto_renew: bool
+    purchased_at: str
+    expires_at: str
+    email_enabled: bool
+    email_verified: bool
+    email_verified_at: Optional[str]
+    mailbox_count: int
+
+
+class Backorder(TypedDict, total=False):
+    id: str
+    domain: str
+    status: Literal["watching", "caught", "failed", "cancelled", "expired"]
+    payment_method: Literal["card", "balance"]
+    max_price: float
+    currency: str
+    domain_expires: Optional[str]
+    last_checked: Optional[str]
+    attempts: int
+    caught_at: Optional[str]
+    registered_domain_id: Optional[str]
+    failure_reason: Optional[str]
+    expires_at: str
+    created_at: str
+
+
+class DealInvoice(TypedDict, total=False):
+    deal_id: str
+    domain: str
+    date: str
+    status: str
+    your_role: Literal["buyer", "seller"]
+    currency: str
+    line_items: List[Dict[str, Any]]
+    total: float
+    commission_rate: float
+    commission_amount: float
+    payment_method: str
+    payout_method: Literal["bank", "balance"]
+    payout_status: Literal["paid", "credited", "pending"]
+
+
+class BrokerRequest(TypedDict, total=False):
+    id: str
+    domain: str
+    status: Literal["sourcing", "contacted", "negotiating", "agreed", "completed", "no_contact", "declined", "expired", "cancelled"]
+    max_budget: Optional[float]
+    contacted: bool
+    negotiation_id: Optional[str]
+    failure_reason: Optional[str]
+    expires_at: str
+    created_at: str
+
+
+class Negotiation(TypedDict, total=False):
+    id: str
+    domain: str
+    status: Literal["open", "agreed", "completed", "declined", "expired", "cancelled"]
+    your_role: Literal["buyer", "seller"]
+    your_turn: bool
+    current_offer: float
+    agreed_price: Optional[float]
+    list_price: float
+    expires_at: str
+    deal_id: Optional[str]
+    created_at: str
+    offers: List[Dict[str, Any]]
+
+
+class DomainDetail(TypedDict, total=False):
+    domain: str
+    status: Literal["active", "expired", "pending"]
+    auto_renew: bool
+    purchased_at: str
+    expires_at: str
+    days_until_expiry: int
+    payment_method: Literal["card", "x402", "crypto"]
+    payment_tx: Optional[str]
+    registrar: Optional[Dict[str, Any]]
+
+
+class TokenInfo(TypedDict, total=False):
+    id: str
+    name: str
+    key: str
+    last_used: Optional[str]
+    expires_at: Optional[str]
+    expired: bool
+    scopes: List[str]
+    created_at: str
+
+
+class Contact(TypedDict, total=False):
+    name: Optional[str]
+    organization: Optional[str]
+    email: Optional[str]
+    phone: Optional[str]
+    fax: Optional[str]
+    street: Optional[str]
+    city: Optional[str]
+    state: Optional[str]
+    postal_code: Optional[str]
+    country: Optional[str]
+
+
+class RegistrantContact(TypedDict, total=False):
+    first_name: str
+    last_name: str
+    org_name: Optional[str]
+    address1: str
+    address2: Optional[str]
+    city: str
+    state: str
+    postal_code: str
+    country: str
+    phone: str
+    email: str
+
+
+class AccountInfo(TypedDict, total=False):
+    id: str
+    email: str
+    has_payment_method: bool
+    has_contact: bool
+    contact: "RegistrantContact"
+    referral_code: str
+    referral_rate: int
+    balance: float
+    domain_count: int
+    token_count: int
+    created_at: str
+
+
+# ─── Client ─────────────────────────────────────────
+
+class Domani:
+    """domani API client. Get an API key at https://domani.run."""
+
+    def __init__(self, api_key: str, base_url: str = DEFAULT_BASE_URL, timeout: float = 30.0):
+        if not api_key:
+            raise ValueError("Domani: api_key is required")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    def _request(self, method: str, path: str, json: Any = None, query: Optional[Dict[str, Any]] = None) -> Any:
+        url = self.base_url + path
+        if query:
+            pairs = []
+            for k, v in query.items():
+                if v is None:
+                    continue
+                if isinstance(v, (list, tuple)):
+                    pairs.extend((k, str(item)) for item in v)
+                else:
+                    pairs.append((k, str(v)))
+            if pairs:
+                url += ("&" if "?" in url else "?") + urllib.parse.urlencode(pairs)
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+        data = None
+        if json is not None:
+            headers["Content-Type"] = "application/json"
+            data = _json.dumps(json).encode("utf-8")
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                text = resp.read().decode("utf-8")
+                return _json.loads(text) if text else None
+        except urllib.error.HTTPError as e:
+            text = e.read().decode("utf-8")
+            body: Any = None
+            if text:
+                try:
+                    body = _json.loads(text)
+                except ValueError:
+                    body = text
+            raise DomaniError(e.code, body) from None
+
+    def add_mailbox_alias(self, address: str, body: Dict[str, Any]) -> Any:
+        """Add a mailbox alias (POST /api/emails/{address}/aliases)"""
+        return self._request("POST", f"/api/emails/{quote(str(address))}/aliases", json=body)
+
+    def add_suppression(self, body: Dict[str, Any]) -> Any:
+        """Add a suppression (POST /api/suppressions)"""
+        return self._request("POST", f"/api/suppressions", json=body)
+
+    def buy_domain(self, body: Dict[str, Any]) -> Any:
+        """Purchase one or more domains (POST /api/domains/buy)"""
+        return self._request("POST", f"/api/domains/buy", json=body)
+
+    def cancel_backorder(self, id: str) -> Any:
+        """Cancel a backorder (DELETE /api/backorders/{id})"""
+        return self._request("DELETE", f"/api/backorders/{quote(str(id))}")
+
+    def cancel_broker_request(self, id: str) -> Any:
+        """Cancel a broker request (DELETE /api/broker/{id})"""
+        return self._request("DELETE", f"/api/broker/{quote(str(id))}")
+
+    def cancel_listing(self, domain: str) -> Any:
+        """Cancel a domain listing (DELETE /api/domains/{domain}/for-sale)"""
+        return self._request("DELETE", f"/api/domains/{quote(str(domain))}/for-sale")
+
+    def cancel_negotiation(self, id: str) -> Any:
+        """Withdraw a negotiation (DELETE /api/negotiations/{id})"""
+        return self._request("DELETE", f"/api/negotiations/{quote(str(id))}")
+
+    def check_email(self, domain: str) -> Any:
+        """Check email DNS health (MX, SPF, DMARC, DKIM) (GET /api/domains/{domain}/email/check)"""
+        return self._request("GET", f"/api/domains/{quote(str(domain))}/email/check")
+
+    def check_transfer_eligibility(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """Pre-check transfer eligibility (GET /api/domains/transfer-check)"""
+        return self._request("GET", f"/api/domains/transfer-check", query=query)
+
+    def check_transfer_status(self, domain: str) -> Any:
+        """Check inbound transfer status (GET /api/domains/{domain}/transfer-status)"""
+        return self._request("GET", f"/api/domains/{quote(str(domain))}/transfer-status")
+
+    def clear_catch_all(self, domain: str) -> Any:
+        """Clear domain catch-all (DELETE /api/domains/{domain}/email/catch-all)"""
+        return self._request("DELETE", f"/api/domains/{quote(str(domain))}/email/catch-all")
+
+    def clear_domain_redirect(self, domain: str) -> Any:
+        """Stop forwarding a domain (DELETE /api/domains/{domain}/redirect)"""
+        return self._request("DELETE", f"/api/domains/{quote(str(domain))}/redirect")
+
+    def connect_domain(self, domain: str, body: Dict[str, Any]) -> Any:
+        """Connect a domain to a hosting or email provider (POST /api/domains/{domain}/connect)"""
+        return self._request("POST", f"/api/domains/{quote(str(domain))}/connect", json=body)
+
+    def create_backorder(self, body: Dict[str, Any]) -> Any:
+        """Place a backorder on a taken domain (POST /api/backorders)"""
+        return self._request("POST", f"/api/backorders", json=body)
+
+    def create_broker_request(self, body: Dict[str, Any]) -> Any:
+        """Request acquisition of a taken domain (POST /api/broker)"""
+        return self._request("POST", f"/api/broker", json=body)
+
+    def create_deal(self, body: Dict[str, Any]) -> Any:
+        """Purchase an external domain (create deal) (POST /api/deals)"""
+        return self._request("POST", f"/api/deals", json=body)
+
+    def create_listing(self, domain: str, body: Dict[str, Any]) -> Any:
+        """List a domain for sale (PUT /api/domains/{domain}/for-sale)"""
+        return self._request("PUT", f"/api/domains/{quote(str(domain))}/for-sale", json=body)
+
+    def create_mailbox(self, body: Dict[str, Any]) -> Any:
+        """Create a mailbox on domani.run (POST /api/email)"""
+        return self._request("POST", f"/api/email", json=body)
+
+    def create_mailbox_by_address(self, body: Dict[str, Any] = None) -> Any:
+        """Create a mailbox (POST /api/emails)"""
+        return self._request("POST", f"/api/emails", json=body)
+
+    def create_token(self, body: Dict[str, Any]) -> Any:
+        """Create a new API token (POST /api/tokens)"""
+        return self._request("POST", f"/api/tokens", json=body)
+
+    def create_webhook(self, body: Dict[str, Any]) -> Any:
+        """Create webhook (POST /api/webhooks)"""
+        return self._request("POST", f"/api/webhooks", json=body)
+
+    def delete_account(self) -> Any:
+        """Delete account and all associated data (DELETE /api/me)"""
+        return self._request("DELETE", f"/api/me")
+
+    def delete_mailbox_by_address(self, address: str, body: Dict[str, Any] = None) -> Any:
+        """Delete a mailbox (DELETE /api/emails/{address})"""
+        return self._request("DELETE", f"/api/emails/{quote(str(address))}", json=body)
+
+    def delete_message_by_address(self, address: str, id: str) -> Any:
+        """Delete a message (DELETE /api/emails/{address}/messages/{id})"""
+        return self._request("DELETE", f"/api/emails/{quote(str(address))}/messages/{quote(str(id))}")
+
+    def delete_messages_by_address(self, address: str, body: Dict[str, Any] = None) -> Any:
+        """Bulk delete messages (POST /api/emails/{address}/messages/delete)"""
+        return self._request("POST", f"/api/emails/{quote(str(address))}/messages/delete", json=body)
+
+    def delete_webhook(self, id: str) -> Any:
+        """Delete webhook (DELETE /api/webhooks/{id})"""
+        return self._request("DELETE", f"/api/webhooks/{quote(str(id))}")
+
+    def dns_check(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """Fast DNS-based domain existence check (GET /api/domains/dns-check)"""
+        return self._request("GET", f"/api/domains/dns-check", query=query)
+
+    def finalize_negotiation(self, id: str, body: Dict[str, Any] = None) -> Any:
+        """Finalize an agreed negotiation (pay) (POST /api/negotiations/{id}/finalize)"""
+        return self._request("POST", f"/api/negotiations/{quote(str(id))}/finalize", json=body)
+
+    def forward_message_by_address(self, address: str, id: str, body: Dict[str, Any] = None) -> Any:
+        """Forward a message (POST /api/emails/{address}/messages/{id}/forward)"""
+        return self._request("POST", f"/api/emails/{quote(str(address))}/messages/{quote(str(id))}/forward", json=body)
+
+    def get_account(self) -> Any:
+        """Get current account details (GET /api/me)"""
+        return self._request("GET", f"/api/me")
+
+    def get_auth_code(self, domain: str) -> Any:
+        """Get EPP auth code (GET /api/domains/{domain}/auth-code)"""
+        return self._request("GET", f"/api/domains/{quote(str(domain))}/auth-code")
+
+    def get_backorder(self, id: str) -> Any:
+        """Get a backorder (GET /api/backorders/{id})"""
+        return self._request("GET", f"/api/backorders/{quote(str(id))}")
+
+    def get_broker_inquiry_state(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """Read a broker inquiry's state (owner side) (GET /api/broker/respond)"""
+        return self._request("GET", f"/api/broker/respond", query=query)
+
+    def get_broker_request(self, id: str) -> Any:
+        """Get a broker request (GET /api/broker/{id})"""
+        return self._request("GET", f"/api/broker/{quote(str(id))}")
+
+    def get_contact(self) -> Any:
+        """Get registrant contact info (GET /api/me/contact)"""
+        return self._request("GET", f"/api/me/contact")
+
+    def get_deal(self, id: str) -> Any:
+        """Get deal detail with timeline (GET /api/deals/{id})"""
+        return self._request("GET", f"/api/deals/{quote(str(id))}")
+
+    def get_deal_invoice(self, id: str) -> Any:
+        """Get a deal receipt / statement (GET /api/deals/{id}/invoice)"""
+        return self._request("GET", f"/api/deals/{quote(str(id))}/invoice")
+
+    def get_dns_records(self, domain: str) -> Any:
+        """Get DNS records for a domain you own (GET /api/domains/{domain}/dns)"""
+        return self._request("GET", f"/api/domains/{quote(str(domain))}/dns")
+
+    def get_domain_email_status(self, domain: str) -> Any:
+        """Check email DNS status (GET /api/domains/{domain}/email/status)"""
+        return self._request("GET", f"/api/domains/{quote(str(domain))}/email/status")
+
+    def get_domain_info(self, domain: str) -> Any:
+        """Get detailed information about a domain you own (GET /api/domains/{domain})"""
+        return self._request("GET", f"/api/domains/{quote(str(domain))}")
+
+    def get_domain_og(self, domain: str) -> Any:
+        """Get website preview metadata for a domain (GET /api/domains/{domain}/og)"""
+        return self._request("GET", f"/api/domains/{quote(str(domain))}/og")
+
+    def get_domain_status(self, domain: str) -> Any:
+        """Check domain health: DNS, SSL, email, expiry (GET /api/domains/{domain}/status)"""
+        return self._request("GET", f"/api/domains/{quote(str(domain))}/status")
+
+    def get_mailbox_avatar_by_address(self, address: str) -> Any:
+        """Get mailbox avatar info (GET /api/emails/{address}/avatar)"""
+        return self._request("GET", f"/api/emails/{quote(str(address))}/avatar")
+
+    def get_mailbox_by_address(self, address: str) -> Any:
+        """Get mailbox details (GET /api/emails/{address})"""
+        return self._request("GET", f"/api/emails/{quote(str(address))}")
+
+    def get_mailbox_webhook(self, address: str) -> Any:
+        """Get mailbox webhook config (GET /api/emails/{address}/webhook)"""
+        return self._request("GET", f"/api/emails/{quote(str(address))}/webhook")
+
+    def get_message_by_address(self, address: str, id: str) -> Any:
+        """Get a message (GET /api/emails/{address}/messages/{id})"""
+        return self._request("GET", f"/api/emails/{quote(str(address))}/messages/{quote(str(id))}")
+
+    def get_nameservers(self, domain: str) -> Any:
+        """Get nameservers for a domain (GET /api/domains/{domain}/nameservers)"""
+        return self._request("GET", f"/api/domains/{quote(str(domain))}/nameservers")
+
+    def get_negotiation(self, id: str) -> Any:
+        """Get a negotiation thread (GET /api/negotiations/{id})"""
+        return self._request("GET", f"/api/negotiations/{quote(str(id))}")
+
+    def get_notification_preferences(self) -> Any:
+        """Get notification preferences (GET /api/notifications/preferences)"""
+        return self._request("GET", f"/api/notifications/preferences")
+
+    def get_parking_analytics(self, domain: str) -> Any:
+        """Get parking analytics (GET /api/domains/{domain}/analytics)"""
+        return self._request("GET", f"/api/domains/{quote(str(domain))}/analytics")
+
+    def get_payout_status(self) -> Any:
+        """Get marketplace payout status (GET /api/billing/connect)"""
+        return self._request("GET", f"/api/billing/connect")
+
+    def get_referrals(self) -> Any:
+        """Get referral earnings and history (GET /api/referrals)"""
+        return self._request("GET", f"/api/referrals")
+
+    def get_sell_status(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """Check listing and deal status (GET /api/domains/sell/status)"""
+        return self._request("GET", f"/api/domains/sell/status", query=query)
+
+    def get_transfer_away(self, domain: str) -> Any:
+        """Get outbound transfer status (GET /api/domains/{domain}/transfer-away)"""
+        return self._request("GET", f"/api/domains/{quote(str(domain))}/transfer-away")
+
+    def get_unread_count(self) -> Any:
+        """Get unread notification count (GET /api/notifications/count)"""
+        return self._request("GET", f"/api/notifications/count")
+
+    def get_webhook_deliveries(self, id: str, query: Optional[Dict[str, Any]] = None) -> Any:
+        """List webhook deliveries (GET /api/webhooks/{id}/deliveries)"""
+        return self._request("GET", f"/api/webhooks/{quote(str(id))}/deliveries", query=query)
+
+    def import_domain(self, body: Dict[str, Any]) -> Any:
+        """Import an external domain (POST /api/domains/import)"""
+        return self._request("POST", f"/api/domains/import", json=body)
+
+    def list_backorders(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """List your backorders (GET /api/backorders)"""
+        return self._request("GET", f"/api/backorders", query=query)
+
+    def list_broker_requests(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """List your broker requests (GET /api/broker)"""
+        return self._request("GET", f"/api/broker", query=query)
+
+    def list_connect_providers(self, domain: str) -> Any:
+        """List available providers for connecting a domain (GET /api/domains/{domain}/connect)"""
+        return self._request("GET", f"/api/domains/{quote(str(domain))}/connect")
+
+    def list_deals(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """List your deals (GET /api/deals)"""
+        return self._request("GET", f"/api/deals", query=query)
+
+    def list_domains(self) -> Any:
+        """List all your registered domains (GET /api/domains)"""
+        return self._request("GET", f"/api/domains")
+
+    def list_email_messages_by_address(self, address: str, query: Optional[Dict[str, Any]] = None) -> Any:
+        """List emails (GET /api/emails/{address}/messages)"""
+        return self._request("GET", f"/api/emails/{quote(str(address))}/messages", query=query)
+
+    def list_invoices(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """List payment invoices (GET /api/billing/invoices)"""
+        return self._request("GET", f"/api/billing/invoices", query=query)
+
+    def list_mailbox_aliases(self, address: str) -> Any:
+        """List mailbox aliases (GET /api/emails/{address}/aliases)"""
+        return self._request("GET", f"/api/emails/{quote(str(address))}/aliases")
+
+    def list_mailboxes(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """List all mailboxes (GET /api/email)"""
+        return self._request("GET", f"/api/email", query=query)
+
+    def list_mailboxes_by_address(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """List all mailboxes (GET /api/emails)"""
+        return self._request("GET", f"/api/emails", query=query)
+
+    def list_negotiations(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """List your negotiations (GET /api/negotiations)"""
+        return self._request("GET", f"/api/negotiations", query=query)
+
+    def list_notifications(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """List notifications (GET /api/notifications)"""
+        return self._request("GET", f"/api/notifications", query=query)
+
+    def list_suppressions(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """List suppressed addresses (GET /api/suppressions)"""
+        return self._request("GET", f"/api/suppressions", query=query)
+
+    def list_tlds(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """List all available TLDs with pricing (GET /api/tlds)"""
+        return self._request("GET", f"/api/tlds", query=query)
+
+    def list_tokens(self) -> Any:
+        """List your API tokens (GET /api/tokens)"""
+        return self._request("GET", f"/api/tokens")
+
+    def list_verify_services(self, domain: str) -> Any:
+        """List supported services for domain verification (GET /api/domains/{domain}/verify-service)"""
+        return self._request("GET", f"/api/domains/{quote(str(domain))}/verify-service")
+
+    def list_webhook_events(self) -> Any:
+        """List webhook event types (GET /api/webhooks/events)"""
+        return self._request("GET", f"/api/webhooks/events")
+
+    def list_webhooks(self) -> Any:
+        """List webhooks (GET /api/webhooks)"""
+        return self._request("GET", f"/api/webhooks")
+
+    def login_user(self, body: Dict[str, Any]) -> Any:
+        """Send a magic link sign-in email (POST /api/auth/login)"""
+        return self._request("POST", f"/api/auth/login", json=body)
+
+    def make_offer(self, body: Dict[str, Any]) -> Any:
+        """Make an offer on a listing (POST /api/negotiations)"""
+        return self._request("POST", f"/api/negotiations", json=body)
+
+    def mark_all_notifications_read(self) -> Any:
+        """Mark all notifications as read (POST /api/notifications/read-all)"""
+        return self._request("POST", f"/api/notifications/read-all")
+
+    def mark_messages_read_by_address(self, address: str, body: Dict[str, Any] = None) -> Any:
+        """Mark messages as read or unread (PATCH /api/emails/{address}/messages/read)"""
+        return self._request("PATCH", f"/api/emails/{quote(str(address))}/messages/read", json=body)
+
+    def mark_notification_read(self, id: str, body: Dict[str, Any]) -> Any:
+        """Mark notification as read (PATCH /api/notifications/{id})"""
+        return self._request("PATCH", f"/api/notifications/{quote(str(id))}", json=body)
+
+    def provide_epp_code(self, id: str, body: Dict[str, Any]) -> Any:
+        """Provide EPP/auth code (seller) (PATCH /api/deals/{id})"""
+        return self._request("PATCH", f"/api/deals/{quote(str(id))}", json=body)
+
+    def provision_agent(self, body: Dict[str, Any]) -> Any:
+        """Provision a complete agent identity in one call (POST /api/agents/provision)"""
+        return self._request("POST", f"/api/agents/provision", json=body)
+
+    def register_user(self, body: Dict[str, Any]) -> Any:
+        """Create a new account (POST /api/auth/register)"""
+        return self._request("POST", f"/api/auth/register", json=body)
+
+    def remove_card(self) -> Any:
+        """Remove saved payment method (DELETE /api/billing/card)"""
+        return self._request("DELETE", f"/api/billing/card")
+
+    def remove_domain_email(self, domain: str) -> Any:
+        """Remove email from a domain (DELETE /api/domains/{domain}/email/setup)"""
+        return self._request("DELETE", f"/api/domains/{quote(str(domain))}/email/setup")
+
+    def remove_mailbox_alias(self, address: str, alias: str) -> Any:
+        """Remove a mailbox alias (DELETE /api/emails/{address}/aliases/{alias})"""
+        return self._request("DELETE", f"/api/emails/{quote(str(address))}/aliases/{quote(str(alias))}")
+
+    def remove_mailbox_webhook(self, address: str) -> Any:
+        """Remove mailbox webhook (DELETE /api/emails/{address}/webhook)"""
+        return self._request("DELETE", f"/api/emails/{quote(str(address))}/webhook")
+
+    def remove_suppression(self, address: str) -> Any:
+        """Remove a suppression (DELETE /api/suppressions/{address})"""
+        return self._request("DELETE", f"/api/suppressions/{quote(str(address))}")
+
+    def renew_domain(self, domain: str, body: Dict[str, Any] = None) -> Any:
+        """Renew a domain (POST /api/domains/{domain}/renew)"""
+        return self._request("POST", f"/api/domains/{quote(str(domain))}/renew", json=body)
+
+    def reply_to_message_by_address(self, address: str, id: str, body: Dict[str, Any] = None) -> Any:
+        """Reply to a message (POST /api/emails/{address}/messages/{id}/reply)"""
+        return self._request("POST", f"/api/emails/{quote(str(address))}/messages/{quote(str(id))}/reply", json=body)
+
+    def resend_email_verification(self, body: Dict[str, Any] = None) -> Any:
+        """Resend contact email verification (POST /api/me/resend-verification)"""
+        return self._request("POST", f"/api/me/resend-verification", json=body)
+
+    def respond_to_broker_inquiry(self, body: Dict[str, Any]) -> Any:
+        """Respond to a broker inquiry (owner side) (POST /api/broker/respond)"""
+        return self._request("POST", f"/api/broker/respond", json=body)
+
+    def respond_to_negotiation(self, id: str, body: Dict[str, Any]) -> Any:
+        """Counter, accept, or decline (POST /api/negotiations/{id})"""
+        return self._request("POST", f"/api/negotiations/{quote(str(id))}", json=body)
+
+    def restore_dns(self, domain: str, body: Dict[str, Any] = None) -> Any:
+        """Restore DNS from a snapshot (POST /api/domains/{domain}/dns/restore)"""
+        return self._request("POST", f"/api/domains/{quote(str(domain))}/dns/restore", json=body)
+
+    def revoke_token(self, id: str) -> Any:
+        """Revoke an API token (DELETE /api/tokens/{id})"""
+        return self._request("DELETE", f"/api/tokens/{quote(str(id))}")
+
+    def rotate_mailbox_webhook_secret(self, address: str) -> Any:
+        """Rotate webhook signing secret (POST /api/emails/{address}/webhook/rotate)"""
+        return self._request("POST", f"/api/emails/{quote(str(address))}/webhook/rotate")
+
+    def search(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """Check availability and pricing for domains (GET /api/domains/search)"""
+        return self._request("GET", f"/api/domains/search", query=query)
+
+    def sell_domain(self, body: Dict[str, Any]) -> Any:
+        """List a domain for sale (open marketplace) (POST /api/domains/sell)"""
+        return self._request("POST", f"/api/domains/sell", json=body)
+
+    def send_email_by_address(self, address: str, body: Dict[str, Any] = None) -> Any:
+        """Send an email (POST /api/emails/{address}/send)"""
+        return self._request("POST", f"/api/emails/{quote(str(address))}/send", json=body)
+
+    def set_catch_all(self, domain: str, body: Dict[str, Any]) -> Any:
+        """Set domain catch-all (PUT /api/domains/{domain}/email/catch-all)"""
+        return self._request("PUT", f"/api/domains/{quote(str(domain))}/email/catch-all", json=body)
+
+    def set_contact(self, body: "RegistrantContact") -> Any:
+        """Set registrant contact info (PUT /api/me/contact)"""
+        return self._request("PUT", f"/api/me/contact", json=body)
+
+    def set_dns_records(self, domain: str, body: Dict[str, Any]) -> Any:
+        """Set DNS records for a domain you own (PUT /api/domains/{domain}/dns)"""
+        return self._request("PUT", f"/api/domains/{quote(str(domain))}/dns", json=body)
+
+    def set_domain_redirect(self, domain: str, body: Dict[str, Any]) -> Any:
+        """Forward a domain to a URL (PUT /api/domains/{domain}/redirect)"""
+        return self._request("PUT", f"/api/domains/{quote(str(domain))}/redirect", json=body)
+
+    def set_mailbox_webhook(self, address: str, body: Dict[str, Any]) -> Any:
+        """Set mailbox webhook (PUT /api/emails/{address}/webhook)"""
+        return self._request("PUT", f"/api/emails/{quote(str(address))}/webhook", json=body)
+
+    def set_nameservers(self, domain: str, body: Dict[str, Any]) -> Any:
+        """Set nameservers for a domain (PUT /api/domains/{domain}/nameservers)"""
+        return self._request("PUT", f"/api/domains/{quote(str(domain))}/nameservers", json=body)
+
+    def setup_billing(self, body: Dict[str, Any] = None) -> Any:
+        """Get checkout URL for adding a payment method (POST /api/billing/setup)"""
+        return self._request("POST", f"/api/billing/setup", json=body)
+
+    def setup_domain_email(self, domain: str, body: Dict[str, Any] = None) -> Any:
+        """Set up email on a domain (POST /api/domains/{domain}/email/setup)"""
+        return self._request("POST", f"/api/domains/{quote(str(domain))}/email/setup", json=body)
+
+    def snapshot_dns(self, domain: str, body: Dict[str, Any] = None) -> Any:
+        """Capture a DNS snapshot (POST /api/domains/{domain}/dns/snapshot)"""
+        return self._request("POST", f"/api/domains/{quote(str(domain))}/dns/snapshot", json=body)
+
+    def start_payout_onboarding(self) -> Any:
+        """Start bank payout onboarding (POST /api/billing/connect)"""
+        return self._request("POST", f"/api/billing/connect")
+
+    def suggest_domains(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """AI-powered domain suggestions with availability (GET /api/domains/suggest)"""
+        return self._request("GET", f"/api/domains/suggest", query=query)
+
+    def test_mailbox_webhook(self, address: str) -> Any:
+        """Test mailbox webhook (POST /api/emails/{address}/webhook/test)"""
+        return self._request("POST", f"/api/emails/{quote(str(address))}/webhook/test")
+
+    def transfer_domain(self, body: Dict[str, Any]) -> Any:
+        """Transfer domain from another provider (POST /api/domains/transfer)"""
+        return self._request("POST", f"/api/domains/transfer", json=body)
+
+    def update_account(self, body: Dict[str, Any]) -> Any:
+        """Update account preferences (PUT /api/me)"""
+        return self._request("PUT", f"/api/me", json=body)
+
+    def update_domain_settings(self, domain: str, body: Dict[str, Any]) -> Any:
+        """Update domain settings (PUT /api/domains/{domain}/settings)"""
+        return self._request("PUT", f"/api/domains/{quote(str(domain))}/settings", json=body)
+
+    def update_listing(self, domain: str, body: Dict[str, Any]) -> Any:
+        """Update a domain listing (PATCH /api/domains/{domain}/for-sale)"""
+        return self._request("PATCH", f"/api/domains/{quote(str(domain))}/for-sale", json=body)
+
+    def update_mailbox_by_address(self, address: str, body: Dict[str, Any] = None) -> Any:
+        """Update mailbox (PATCH /api/emails/{address})"""
+        return self._request("PATCH", f"/api/emails/{quote(str(address))}", json=body)
+
+    def update_notification_preferences(self, body: Dict[str, Any]) -> Any:
+        """Update notification preferences (PUT /api/notifications/preferences)"""
+        return self._request("PUT", f"/api/notifications/preferences", json=body)
+
+    def update_parking(self, domain: str, body: Dict[str, Any]) -> Any:
+        """Update parking settings (PUT /api/domains/{domain}/parking)"""
+        return self._request("PUT", f"/api/domains/{quote(str(domain))}/parking", json=body)
+
+    def update_webhook(self, id: str, body: Dict[str, Any]) -> Any:
+        """Update webhook (PATCH /api/webhooks/{id})"""
+        return self._request("PATCH", f"/api/webhooks/{quote(str(id))}", json=body)
+
+    def verify_connection(self, domain: str, body: Dict[str, Any]) -> Any:
+        """Verify that a provider connection is working (POST /api/domains/{domain}/verify)"""
+        return self._request("POST", f"/api/domains/{quote(str(domain))}/verify", json=body)
+
+    def verify_import(self, body: Dict[str, Any]) -> Any:
+        """Verify and complete domain import (POST /api/domains/import/verify)"""
+        return self._request("POST", f"/api/domains/import/verify", json=body)
+
+    def verify_magic_link(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """Verify a magic link token (GET /api/auth/verify)"""
+        return self._request("GET", f"/api/auth/verify", query=query)
+
+    def verify_sell_listing(self, body: Dict[str, Any]) -> Any:
+        """Verify TXT ownership for external listing (POST /api/domains/sell/verify)"""
+        return self._request("POST", f"/api/domains/sell/verify", json=body)
+
+    def verify_service(self, domain: str, body: Dict[str, Any]) -> Any:
+        """Add DNS records to verify domain ownership for a third-party service (POST /api/domains/{domain}/verify-service)"""
+        return self._request("POST", f"/api/domains/{quote(str(domain))}/verify-service", json=body)
+
+    def watch_transfer(self, body: Dict[str, Any]) -> Any:
+        """Watch a domain for transfer eligibility (POST /api/domains/transfer-watch)"""
+        return self._request("POST", f"/api/domains/transfer-watch", json=body)
+
+    def whois_lookup(self, query: Optional[Dict[str, Any]] = None) -> Any:
+        """Look up domain registration data via RDAP (GET /api/domains/whois)"""
+        return self._request("GET", f"/api/domains/whois", query=query)
+
+    def withdraw_balance(self) -> Any:
+        """Withdraw marketplace balance to bank (POST /api/billing/connect/payout)"""
+        return self._request("POST", f"/api/billing/connect/payout")

domani-0.1.0/e2e_check.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""End-to-end check for the domani Python SDK against a running server.
+
+Reads DOMANI_API_KEY, DOMANI_BASE_URL, DOMANI_DOMAIN from the environment,
+runs the README quickstart flow, and exits 0 on success / 1 on any failure.
+Invoked by the `sdk.python_e2e` eval scenario; also runnable by hand against a
+booted mock-mode server.
+"""
+import os
+import sys
+
+# Import the sibling package without installing it.
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from domani import Domani, DomaniError  # noqa: E402
+
+
+def fail(msg):
+    print(f"[sdk-py-e2e] FAIL: {msg}", file=sys.stderr)
+    sys.exit(1)
+
+
+def main():
+    api_key = os.environ.get("DOMANI_API_KEY")
+    base_url = os.environ.get("DOMANI_BASE_URL")
+    domain = os.environ.get("DOMANI_DOMAIN")
+    if not (api_key and base_url and domain):
+        fail("DOMANI_API_KEY, DOMANI_BASE_URL, DOMANI_DOMAIN must be set")
+
+    domani = Domani(api_key=api_key, base_url=base_url)
+    address = f"hi@{domain}"
+
+    # Typed search (README shape: search(query={...}))
+    results = domani.search(query={"q": f"sdk-py-{domain}"})
+    if not isinstance(results, dict):
+        fail(f"search returned non-dict: {results!r}")
+
+    # Create a mailbox (README shape)
+    mb = domani.create_mailbox_by_address(body={"address": address})
+    if not isinstance(mb, dict) or mb.get("address") != address:
+        fail(f"create_mailbox address mismatch: {mb!r}")
+
+    # Send (README shape)
+    sent = domani.send_email_by_address(
+        address, body={"to": "user@example.com", "subject": "SDK E2E", "text": "hi from the Python SDK"}
+    )
+    if not isinstance(sent, dict) or not sent.get("status"):
+        fail(f"send returned no status: {sent!r}")
+
+    # Suppression: add -> list -> a blocked send raises DomaniError -> remove
+    domani.add_suppression(body={"address": "blocked@example.com"})
+    listed = domani.list_suppressions()
+    addrs = [s.get("address") for s in (listed or {}).get("suppressions", [])]
+    if "blocked@example.com" not in addrs:
+        fail(f"suppression not listed: {listed!r}")
+
+    raised = False
+    try:
+        domani.send_email_by_address(address, body={"to": "blocked@example.com", "text": "should be blocked"})
+    except DomaniError as e:
+        if e.status == 400 and e.code == "RECIPIENTS_SUPPRESSED":
+            raised = True
+        else:
+            fail(f"wrong DomaniError: {e.status} {e.code}")
+    if not raised:
+        fail("blocked send should have raised DomaniError")
+
+    domani.remove_suppression("blocked@example.com")
+    print("[sdk-py-e2e] OK")
+
+
+if __name__ == "__main__":
+    main()

domani-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "domani"
+version = "0.1.0"
+description = "Official Python SDK for the domani API - domains, email, and identity for AI agents."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+keywords = ["domani", "domains", "email", "api", "sdk", "agents", "mcp"]
+authors = [{ name = "domani" }]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Intended Audience :: Developers",
+]
+
+[project.urls]
+Homepage = "https://domani.run"
+Repository = "https://github.com/gwendall/domani"
+
+[tool.hatch.build.targets.wheel]
+packages = ["domani"]