namecheap-python 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

namecheap/__init__.py

@@ -12,15 +12,29 @@ from __future__ import annotations
 
 from .client import Namecheap
 from .errors import ConfigurationError, NamecheapError, ValidationError
-from .models import Contact, DNSRecord, Domain, DomainCheck, Nameservers
+from .models import (
+    AccountBalance,
+    Contact,
+    DNSRecord,
+    Domain,
+    DomainCheck,
+    DomainContacts,
+    DomainInfo,
+    EmailForward,
+    Nameservers,
+)
 
-__version__ = "1.1.0"
+__version__ = "1.3.0"
 __all__ = [
+    "AccountBalance",
     "ConfigurationError",
     "Contact",
     "DNSRecord",
     "Domain",
     "DomainCheck",
+    "DomainContacts",
+    "DomainInfo",
+    "EmailForward",
     "Namecheap",
     "NamecheapError",
     "Nameservers",

namecheap/_api/dns.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any, Literal
 
 import tldextract
 
-from namecheap.models import DNSRecord, Nameservers
+from namecheap.models import DNSRecord, EmailForward, Nameservers
 
 from .base import BaseAPI
 
@@ -494,3 +494,75 @@ class DnsAPI(BaseAPI):
         nameservers = [ns_data] if isinstance(ns_data, str) else ns_data
 
         return Nameservers(is_default=is_default, nameservers=nameservers)
+
+    def get_email_forwarding(self, domain: str) -> list[EmailForward]:
+        """
+        Get email forwarding rules for a domain.
+
+        Args:
+            domain: Domain name
+
+        Returns:
+            List of EmailForward rules
+
+        Examples:
+            >>> rules = nc.dns.get_email_forwarding("example.com")
+            >>> for r in rules:
+            ...     print(f"{r.mailbox} -> {r.forward_to}")
+        """
+        result: Any = self._request(
+            "namecheap.domains.dns.getEmailForwarding",
+            {"DomainName": domain},
+            path="DomainDNSGetEmailForwardingResult",
+        )
+
+        if not result:
+            return []
+
+        forwards = result.get("Forward", [])
+        if isinstance(forwards, dict):
+            forwards = [forwards]
+        assert isinstance(forwards, list), f"Unexpected Forward type: {type(forwards)}"
+
+        return [
+            EmailForward(mailbox=f.get("@mailbox", ""), forward_to=f.get("#text", ""))
+            for f in forwards
+        ]
+
+    def set_email_forwarding(
+        self, domain: str, rules: list[EmailForward] | list[dict[str, str]]
+    ) -> bool:
+        """
+        Set email forwarding rules for a domain. Replaces all existing rules.
+
+        Args:
+            domain: Domain name
+            rules: List of EmailForward or dicts with 'mailbox' and 'forward_to' keys
+
+        Returns:
+            True if successful
+
+        Examples:
+            >>> nc.dns.set_email_forwarding("example.com", [
+            ...     EmailForward(mailbox="info", forward_to="me@gmail.com"),
+            ...     EmailForward(mailbox="support", forward_to="help@gmail.com"),
+            ... ])
+        """
+        assert rules, "At least one forwarding rule is required"
+
+        params: dict[str, Any] = {"DomainName": domain}
+        for i, rule in enumerate(rules, 1):
+            if isinstance(rule, EmailForward):
+                params[f"MailBox{i}"] = rule.mailbox
+                params[f"ForwardTo{i}"] = rule.forward_to
+            else:
+                params[f"MailBox{i}"] = rule["mailbox"]
+                params[f"ForwardTo{i}"] = rule["forward_to"]
+
+        result: Any = self._request(
+            "namecheap.domains.dns.setEmailForwarding",
+            params,
+            path="DomainDNSSetEmailForwardingResult",
+        )
+
+        return bool(result and result.get("@IsSuccess", "false").lower() == "true")

namecheap/_api/domains.py

@@ -9,7 +9,7 @@ from typing import Any
 import tldextract
 
 from namecheap.logging import logger
-from namecheap.models import Contact, Domain, DomainCheck
+from namecheap.models import Contact, Domain, DomainCheck, DomainContacts, DomainInfo
 
 from .base import BaseAPI
 
@@ -110,6 +110,98 @@ class DomainsAPI(BaseAPI):
             return [results]
         return results if isinstance(results, list) else []
 
+    def get_info(self, domain: str) -> DomainInfo:
+        """
+        Get detailed information about a domain.
+
+        Args:
+            domain: Domain name
+
+        Returns:
+            DomainInfo with status, whoisguard, DNS provider, etc.
+
+        Examples:
+            >>> info = nc.domains.get_info("example.com")
+            >>> print(f"{info.domain} status={info.status} whoisguard={info.whoisguard_enabled}")
+        """
+        result: Any = self._request(
+            "namecheap.domains.getInfo",
+            {"DomainName": domain},
+            path="DomainGetInfoResult",
+        )
+
+        assert result, f"API returned empty result for {domain} getInfo"
+
+        # Extract nested fields into flat structure
+        domain_details = result.get("DomainDetails", {})
+        whoisguard = result.get("Whoisguard", {})
+        dns_details = result.get("DnsDetails", {})
+
+        flat = {
+            "@ID": result.get("@ID"),
+            "@DomainName": result.get("@DomainName"),
+            "@OwnerName": result.get("@OwnerName"),
+            "@IsOwner": result.get("@IsOwner"),
+            "@IsPremium": result.get("@IsPremium", "false"),
+            "@Status": result.get("@Status"),
+            "created": domain_details.get("CreatedDate"),
+            "expires": domain_details.get("ExpiredDate"),
+            "whoisguard_enabled": whoisguard.get("@Enabled", "false").lower() == "true"
+            if isinstance(whoisguard, dict)
+            else False,
+            "dns_provider": dns_details.get("@ProviderType")
+            if isinstance(dns_details, dict)
+            else None,
+        }
+
+        return DomainInfo.model_validate(flat)
+
+    def get_contacts(self, domain: str) -> DomainContacts:
+        """
+        Get contact information for a domain.
+
+        Args:
+            domain: Domain name
+
+        Returns:
+            DomainContacts with registrant, tech, admin, and aux_billing contacts
+
+        Examples:
+            >>> contacts = nc.domains.get_contacts("example.com")
+            >>> print(contacts.registrant.email)
+        """
+        result: Any = self._request(
+            "namecheap.domains.getContacts",
+            {"DomainName": domain},
+            path="DomainContactsResult",
+        )
+
+        assert result, f"API returned empty result for {domain} getContacts"
+
+        def parse_contact(data: dict[str, Any]) -> Contact:
+            return Contact.model_validate(
+                {
+                    "FirstName": data.get("FirstName", ""),
+                    "LastName": data.get("LastName", ""),
+                    "Organization": data.get("Organization"),
+                    "Address1": data.get("Address1", ""),
+                    "Address2": data.get("Address2"),
+                    "City": data.get("City", ""),
+                    "StateProvince": data.get("StateProvince", ""),
+                    "PostalCode": data.get("PostalCode", ""),
+                    "Country": data.get("Country", ""),
+                    "Phone": data.get("Phone", ""),
+                    "EmailAddress": data.get("EmailAddress", ""),
+                }
+            )
+
+        return DomainContacts(
+            registrant=parse_contact(result.get("Registrant", {})),
+            tech=parse_contact(result.get("Tech", {})),
+            admin=parse_contact(result.get("Admin", {})),
+            aux_billing=parse_contact(result.get("AuxBilling", {})),
+        )
+
     def register(
         self,
         domain: str,

namecheap/_api/users.py

@@ -0,0 +1,32 @@
+"""Users API."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from namecheap.models import AccountBalance
+
+from .base import BaseAPI
+
+
+class UsersAPI(BaseAPI):
+    """User account operations."""
+
+    def get_balances(self) -> AccountBalance:
+        """
+        Get account balance information.
+
+        Returns:
+            AccountBalance with available balance, earned amount, etc.
+
+        Examples:
+            >>> bal = nc.users.get_balances()
+            >>> print(f"{bal.available_balance} {bal.currency}")
+        """
+        result: Any = self._request(
+            "namecheap.users.getBalances",
+            path="UserGetBalancesResult",
+        )
+
+        assert result, "API returned empty result for getBalances"
+        return AccountBalance.model_validate(result)

namecheap/client.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
 
     from ._api.dns import DnsAPI
     from ._api.domains import DomainsAPI
+    from ._api.users import UsersAPI
 
 
 class Namecheap:
@@ -110,6 +111,13 @@ class Namecheap:
 
         return DnsAPI(self)
 
+    @cached_property
+    def users(self) -> UsersAPI:
+        """User account operations."""
+        from ._api.users import UsersAPI
+
+        return UsersAPI(self)
+
     def __enter__(self) -> Self:
         """Enter context manager."""
         return self

namecheap/models.py

@@ -251,6 +251,66 @@ class Domain(XMLModel):
         raise ValueError(f"Cannot parse datetime from {v}")
 
 
+class AccountBalance(BaseModel):
+    """Account balance information."""
+
+    currency: str = Field(alias="@Currency")
+    available_balance: Decimal = Field(alias="@AvailableBalance")
+    account_balance: Decimal = Field(alias="@AccountBalance")
+    earned_amount: Decimal = Field(alias="@EarnedAmount")
+    withdrawable_amount: Decimal = Field(alias="@WithdrawableAmount")
+    funds_required_for_auto_renew: Decimal = Field(alias="@FundsRequiredForAutoRenew")
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    @field_validator(
+        "available_balance",
+        "account_balance",
+        "earned_amount",
+        "withdrawable_amount",
+        "funds_required_for_auto_renew",
+        mode="before",
+    )
+    @classmethod
+    def parse_decimal(cls, v: Any) -> Decimal:
+        return Decimal(str(v)) if v is not None else Decimal("0")
+
+
+class DomainInfo(BaseModel):
+    """Detailed domain information from getInfo."""
+
+    id: int = Field(alias="@ID")
+    domain: str = Field(alias="@DomainName")
+    owner: str = Field(alias="@OwnerName")
+    is_owner: bool = Field(alias="@IsOwner")
+    is_premium: bool = Field(alias="@IsPremium", default=False)
+    status: str = Field(alias="@Status")
+    created: str | None = Field(default=None)
+    expires: str | None = Field(default=None)
+    whoisguard_enabled: bool = Field(default=False)
+    dns_provider: str | None = Field(default=None)
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    @field_validator("is_owner", "is_premium", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() == "true"
+        return False
+
+
+class EmailForward(BaseModel):
+    """Email forwarding rule."""
+
+    mailbox: str = Field(alias="@mailbox")
+    forward_to: str
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
 class Nameservers(BaseModel):
     """Current nameserver configuration for a domain."""
 
@@ -276,6 +336,17 @@ class Contact(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
 
 
+class DomainContacts(BaseModel):
+    """Contact information for all roles on a domain."""
+
+    registrant: Contact
+    tech: Contact
+    admin: Contact
+    aux_billing: Contact
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
 class Config(BaseModel):
     """Client configuration with validation."""
 

namecheap_cli/__main__.py

@@ -367,57 +367,31 @@ def domain_info(config: Config, domain: str) -> None:
     nc = config.init_client()
 
     try:
-        domains = nc.domains.list()
-        domain_obj = next((d for d in domains if d.name == domain), None)
-
-        if not domain_obj:
-            console.print(f"[red]❌ Domain {domain} not found in your account[/red]")
-            sys.exit(1)
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(f"Getting info for {domain}...", total=None)
+            info = nc.domains.get_info(domain)
 
         if config.output_format == "table":
             console.print(f"\n[bold cyan]Domain Information: {domain}[/bold cyan]\n")
-            console.print(
-                f"[bold]Status:[/bold] "
-                f"{'Active' if not domain_obj.is_expired else '[red]Expired[/red]'}"
-            )
-            console.print(
-                f"[bold]Created:[/bold] {domain_obj.created.strftime('%Y-%m-%d')}"
-            )
-            console.print(
-                f"[bold]Expires:[/bold] {domain_obj.expires.strftime('%Y-%m-%d')}"
-            )
-            console.print(
-                f"[bold]Auto-Renew:[/bold] {'✓ Enabled' if domain_obj.auto_renew else '✗ Disabled'}"
-            )
-            console.print(
-                f"[bold]Locked:[/bold] {'🔒 Yes' if domain_obj.is_locked else '🔓 No'}"
-            )
+            console.print(f"[bold]Status:[/bold] {info.status}")
+            console.print(f"[bold]Owner:[/bold] {info.owner}")
+            if info.created:
+                console.print(f"[bold]Created:[/bold] {info.created}")
+            if info.expires:
+                console.print(f"[bold]Expires:[/bold] {info.expires}")
+            console.print(f"[bold]Premium:[/bold] {'Yes' if info.is_premium else 'No'}")
             console.print(
                 f"[bold]WHOIS Guard:[/bold] "
-                f"{'✓ Enabled' if domain_obj.whois_guard else '✗ Disabled'}"
+                f"{'✓ Enabled' if info.whoisguard_enabled else '✗ Disabled'}"
             )
-
-            # Calculate days until expiration
-            days_left = (domain_obj.expires - datetime.now()).days
-            if days_left < 30:
-                console.print(
-                    f"\n⚠️  [yellow]Domain expires in {days_left} days![/yellow]"
-                )
-            elif days_left < 60:
-                console.print(f"\n📅 Domain expires in {days_left} days")
-
+            if info.dns_provider:
+                console.print(f"[bold]DNS Provider:[/bold] {info.dns_provider}")
         else:
-            data = {
-                "domain": domain_obj.name,
-                "status": "active" if not domain_obj.is_expired else "expired",
-                "created": domain_obj.created.isoformat(),
-                "expires": domain_obj.expires.isoformat(),
-                "auto_renew": domain_obj.auto_renew,
-                "locked": domain_obj.is_locked,
-                "whois_guard": domain_obj.whois_guard,
-                "days_until_expiration": (domain_obj.expires - datetime.now()).days,
-            }
-            output_formatter(data, config.output_format)
+            output_formatter(info.model_dump(), config.output_format)
 
     except NamecheapError as e:
         console.print(f"[red]❌ Error: {e}[/red]")
@@ -906,6 +880,142 @@ def dns_export(config: Config, domain: str, format: str, output) -> None:
         sys.exit(1)
 
 
+@dns_group.command("email-forwarding")
+@click.argument("domain")
+@pass_config
+def dns_email_forwarding(config: Config, domain: str) -> None:
+    """Show email forwarding rules for a domain."""
+    nc = config.init_client()
+
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(f"Getting email forwarding for {domain}...", total=None)
+            rules = nc.dns.get_email_forwarding(domain)
+
+        if config.output_format == "table":
+            if not rules:
+                console.print(
+                    f"\n[yellow]No email forwarding rules for {domain}[/yellow]"
+                )
+                return
+
+            table = Table(title=f"Email Forwarding for {domain}")
+            table.add_column("Mailbox", style="cyan")
+            table.add_column("Forwards To", style="green")
+
+            for rule in rules:
+                table.add_row(f"{rule.mailbox}@{domain}", rule.forward_to)
+
+            console.print(table)
+        else:
+            output_formatter([r.model_dump() for r in rules], config.output_format)
+
+    except NamecheapError as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        sys.exit(1)
+
+
+@dns_group.command("set-email-forwarding")
+@click.argument("domain")
+@click.argument("rules", nargs=-1, required=True)
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation")
+@pass_config
+def dns_set_email_forwarding(
+    config: Config, domain: str, rules: tuple[str, ...], yes: bool
+) -> None:
+    """Set email forwarding rules. Replaces all existing rules.
+
+    Rules are in mailbox:forward_to format.
+
+    Example:
+        namecheap-cli dns set-email-forwarding example.com info:me@gmail.com support:help@gmail.com
+    """
+    nc = config.init_client()
+
+    parsed = []
+    for rule in rules:
+        assert ":" in rule, f"Invalid rule format '{rule}', expected mailbox:forward_to"
+        mailbox, forward_to = rule.split(":", 1)
+        parsed.append({"mailbox": mailbox, "forward_to": forward_to})
+
+    try:
+        if not yes and not config.quiet:
+            console.print(f"\n[yellow]Setting email forwarding for {domain}:[/yellow]")
+            for p in parsed:
+                console.print(f"  • {p['mailbox']}@{domain} → {p['forward_to']}")
+            console.print()
+
+            if not Confirm.ask("Continue?", default=True):
+                console.print("[yellow]Cancelled[/yellow]")
+                return
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(f"Setting email forwarding for {domain}...", total=None)
+            success = nc.dns.set_email_forwarding(domain, parsed)
+
+        if success:
+            console.print("[green]✅ Email forwarding updated successfully![/green]")
+        else:
+            console.print("[red]❌ Failed to update email forwarding[/red]")
+            sys.exit(1)
+
+    except NamecheapError as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        sys.exit(1)
+
+
+@domain_group.command("contacts")
+@click.argument("domain")
+@pass_config
+def domain_contacts(config: Config, domain: str) -> None:
+    """Show contact information for a domain."""
+    nc = config.init_client()
+
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(f"Getting contacts for {domain}...", total=None)
+            contacts = nc.domains.get_contacts(domain)
+
+        if config.output_format == "table":
+            for role, contact in [
+                ("Registrant", contacts.registrant),
+                ("Tech", contacts.tech),
+                ("Admin", contacts.admin),
+                ("Billing", contacts.aux_billing),
+            ]:
+                console.print(f"\n[bold cyan]{role}[/bold cyan]")
+                console.print(f"  {contact.first_name} {contact.last_name}")
+                if contact.organization:
+                    console.print(f"  {contact.organization}")
+                console.print(f"  {contact.email}")
+                console.print(f"  {contact.phone}")
+                console.print(f"  {contact.address1}")
+                if contact.address2:
+                    console.print(f"  {contact.address2}")
+                console.print(
+                    f"  {contact.city}, {contact.state_province} {contact.postal_code}"
+                )
+                console.print(f"  {contact.country}")
+        else:
+            output_formatter(contacts.model_dump(), config.output_format)
+
+    except NamecheapError as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        sys.exit(1)
+
+
 @cli.group("account")
 def account_group() -> None:
     """Account management commands."""
@@ -916,14 +1026,37 @@ def account_group() -> None:
 @pass_config
 def account_balance(config: Config) -> None:
     """Check account balance."""
-    config.init_client()
+    nc = config.init_client()
 
     try:
-        # This would need to be implemented in the SDK
-        console.print(
-            "[yellow]Account balance check not yet implemented in SDK[/yellow]"
-        )
-        console.print("This feature requires the users.getBalances API method")
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task("Getting account balance...", total=None)
+            bal = nc.users.get_balances()
+
+        if config.output_format == "table":
+            table = Table(title="Account Balance")
+            table.add_column("Field", style="cyan")
+            table.add_column("Amount", style="green", justify="right")
+
+            table.add_row(
+                "Available Balance", f"{bal.available_balance} {bal.currency}"
+            )
+            table.add_row("Account Balance", f"{bal.account_balance} {bal.currency}")
+            table.add_row("Earned Amount", f"{bal.earned_amount} {bal.currency}")
+            table.add_row("Withdrawable", f"{bal.withdrawable_amount} {bal.currency}")
+            if bal.funds_required_for_auto_renew > 0:
+                table.add_row(
+                    "Auto-Renew Required",
+                    f"{bal.funds_required_for_auto_renew} {bal.currency}",
+                )
+
+            console.print(table)
+        else:
+            output_formatter(bal.model_dump(mode="json"), config.output_format)
 
     except NamecheapError as e:
         console.print(f"[red]❌ Error: {e}[/red]")

{namecheap_python-1.1.0.dist-info → namecheap_python-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: namecheap-python
-Version: 1.1.0
+Version: 1.3.0
 Summary: A friendly Python SDK for Namecheap API
 Project-URL: Homepage, https://github.com/adriangalilea/namecheap-python
 Project-URL: Repository, https://github.com/adriangalilea/namecheap-python
@@ -42,6 +42,12 @@ Description-Content-Type: text/markdown
 
 # Namecheap Python SDK
 
+[![PyPI version](https://badge.fury.io/py/namecheap-python.svg)](https://pypi.org/project/namecheap-python/)
+[![Downloads](https://pepy.tech/badge/namecheap-python)](https://pepy.tech/project/namecheap-python)
+[![Downloads/month](https://pepy.tech/badge/namecheap-python/month)](https://pepy.tech/project/namecheap-python)
+[![Python](https://img.shields.io/pypi/pyversions/namecheap-python)](https://pypi.org/project/namecheap-python/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 A modern, friendly Python SDK for the Namecheap API with comprehensive CLI and TUI tools.
 
 ## 🚀 Features
@@ -206,6 +212,38 @@ Adding CNAME record to tdo.garden...
 ```
 
 
+Check account balance:
+
+```bash
+❯ namecheap-cli account balance
+          Account Balance
+┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━┓
+┃ Field               ┃    Amount ┃
+┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━┩
+│ Available Balance   │  0.00 USD │
+│ Account Balance     │  0.00 USD │
+│ Earned Amount       │  0.00 USD │
+│ Withdrawable        │  0.00 USD │
+│ Auto-Renew Required │ 20.16 USD │
+└─────────────────────┴───────────┘
+```
+
+Get detailed domain info:
+
+```bash
+❯ namecheap-cli domain info self.fm
+
+Domain Information: self.fm
+
+Status: Ok
+Owner: adriangalilea
+Created: 07/15/2023
+Expires: 07/15/2026
+Premium: No
+WHOIS Guard: ✓ Enabled
+DNS Provider: CUSTOM
+```
+
 You can also export DNS records:
 
 ```bash
@@ -320,6 +358,48 @@ nc.dns.set_custom_nameservers("example.com", [
 nc.dns.set_default_nameservers("example.com")
 ```
 
+### Domain Info
+
+```python
+info = nc.domains.get_info("example.com")
+print(info.status)              # 'Ok'
+print(info.whoisguard_enabled)  # True
+print(info.dns_provider)        # 'CUSTOM'
+print(info.created)             # '07/15/2023'
+print(info.expires)             # '07/15/2026'
+```
+
+### Account Balance
+
+```python
+bal = nc.users.get_balances()
+print(f"{bal.available_balance} {bal.currency}")  # '4932.96 USD'
+print(bal.funds_required_for_auto_renew)          # Decimal('20.16')
+```
+
+### Email Forwarding
+
+```python
+# Read
+rules = nc.dns.get_email_forwarding("example.com")
+for r in rules:
+    print(f"{r.mailbox} -> {r.forward_to}")
+
+# Write (replaces all existing rules)
+nc.dns.set_email_forwarding("example.com", [
+    EmailForward(mailbox="info", forward_to="me@gmail.com"),
+    EmailForward(mailbox="support", forward_to="help@gmail.com"),
+])
+```
+
+### Domain Contacts
+
+```python
+contacts = nc.domains.get_contacts("example.com")
+print(f"{contacts.registrant.first_name} {contacts.registrant.last_name}")
+print(contacts.registrant.email)
+```
+
 ### Domain Management
 
 ```python
@@ -393,22 +473,23 @@ nc.dns.builder().a("www", "192.0.2.1", ttl=1799)  # Shows as "Automatic"
 nc.dns.builder().a("www", "192.0.2.1", ttl=1800)  # Shows as "30 min"
 ```
 
-## 🚧 Pending Features
-
-The following Namecheap API features are planned for future releases:
-
-- **SSL API** - Certificate management
-- **Domain Transfer API** - Transfer domains between registrars
-- **Domain NS API** - Glue record management (child nameservers)
-- **Users API** - Account management and balance checking
-- **Whois API** - WHOIS information lookups
-- **Email Forwarding** - Email forwarding configuration
+## 📊 [API Coverage](https://www.namecheap.com/support/api/methods/)
 
-See [pending.md](pending.md) for full details.
+| API | Status | Methods |
+|-----|--------|---------|
+| `namecheap.domains.*` | ✅ Done | `check`, `list`, `getInfo`, `getContacts`, `register`, `renew`, `setContacts`, `lock`/`unlock` |
+| `namecheap.domains.dns.*` | ✅ Done | `getHosts`, `setHosts` (builder pattern), `add`, `delete`, `export`, `getList`, `setCustom`, `setDefault`, `getEmailForwarding`, `setEmailForwarding` |
+| `namecheap.users.*` | ⚠️ Partial | `getBalances`, `getPricing` (needs debugging). Planned: `changePassword`, `update`, `create`, `login`, `resetPassword` |
+| `namecheap.domains.*` | 🚧 Planned | `getTldList`, `reactivate` |
+| `namecheap.users.address.*` | 🚧 Planned | `create`, `delete`, `getInfo`, `getList`, `setDefault`, `update` |
+| `namecheap.ssl.*` | 🚧 Planned | `create`, `activate`, `renew`, `revoke`, `getList`, `getInfo`, `parseCSR`, `reissue`, and more |
+| `namecheap.domains.transfer.*` | 🚧 Planned | `create`, `getStatus`, `updateStatus`, `getList` |
+| `namecheap.domains.ns.*` | 🚧 Planned | Glue records — `create`, `delete`, `getInfo`, `update` |
+| `namecheap.domainprivacy.*` | 🚧 Planned | `enable`, `disable`, `renew`, `getList`, `changeemailaddress` |
 
 ## 🛠️ Development
 
-See [Development Guide](docs/dev/README.md) for detailed development instructions.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for setup and development guidelines.
 
 ## 📝 License
 
@@ -420,4 +501,6 @@ Contributions are welcome! Please feel free to submit a Pull Request. See the [D
 
 ### Contributors
 
+- [@huntertur](https://github.com/huntertur) — Rich dependency fix
+- [@jeffmcadams](https://github.com/jeffmcadams) — Domain serialization round-trip
 - [@cosmin](https://github.com/cosmin) — Nameserver management

{namecheap_python-1.1.0.dist-info → namecheap_python-1.3.0.dist-info}/RECORD

@@ -1,15 +1,16 @@
-namecheap/__init__.py,sha256=anOp8HDUUv8KiSr3Ia1Cs6gcShrWP955iBTJ4y3aB_M,698
-namecheap/client.py,sha256=wnhCA5zeZMGypD1uNHbMYCGoP9paaZjtYZucBUsEY6k,6441
+namecheap/__init__.py,sha256=sUX2-G_o6k1POjfJ9oV32Hi08zaPNL4WwfgrLr_2Qak,879
+namecheap/client.py,sha256=KesIaZVa9HpXvlp-hc3nr2x-sqzMPiHEa8NibiPq580,6644
 namecheap/errors.py,sha256=5bGbV1e4_jkK8YXZXbLF6GJCVUTKw1CtMl9-mz7ogZg,5010
 namecheap/logging.py,sha256=lMR1fr1dWWz3z2NFEY-vl8b52FmmhH76R2NjyifSdYA,3396
-namecheap/models.py,sha256=4n5q7MhukmLUIK1ekNXf51lfwzF08yJVoI2_b3vafXI,12356
+namecheap/models.py,sha256=0Fhni7yKd84bBopPURIvhwmOCYMzw8tlZwHWzRRZphY,14494
 namecheap/_api/__init__.py,sha256=ymQxKCySphoeoo4s_J0tLziXttLNhOQ8AZbCzFcuAHs,36
 namecheap/_api/base.py,sha256=FoczO1Q860PaFUFv-S3IoIV2xaGVJAlchkWnmTI6dlw,6121
-namecheap/_api/dns.py,sha256=c8aBHIugJx1DjCVC1F8cu8Z4aBZMVz6eQaBZrklGUQc,14795
-namecheap/_api/domains.py,sha256=h6cWc03iCwPqOJTfbR8pyom_8MUVPoqSIRJRws1i3UY,16603
+namecheap/_api/dns.py,sha256=Hny5TsVWmmG-3rF6kb8JwboGFt2wKsd4-Z6T8GannBM,17213
+namecheap/_api/domains.py,sha256=txikTYACM82-3IXg2Gqagh9fRZ8aIZiu05unNpy2Zqs,20039
+namecheap/_api/users.py,sha256=CCXSZJiPkQiLHYRAlYKTBCDG3-JSPdNkNWWww71JXV0,795
 namecheap_cli/README.md,sha256=liduIiGr8DHXGTht5swrYnvtAlcdCMQOnSdCD61g4Vw,7337
 namecheap_cli/__init__.py,sha256=nGRHc_CkO4xKhSQdAVG-koEffP8VS0TvbfbZkg7Jg4k,108
-namecheap_cli/__main__.py,sha256=_xZ8uGxpv1mtJGI2IjYw7WbVf6vQ5kkRkoR2OsSp37o,35153
+namecheap_cli/__main__.py,sha256=0vHk5aAhEzPKQ-UQOQdYqsolCF13DG3k9_z3pUbZXwk,40020
 namecheap_cli/completion.py,sha256=JTEMnceQli7TombjZkHh-IcZKW4RFRI8Yk5VynxPsEA,2777
 namecheap_dns_tui/README.md,sha256=It16ZiZh0haEeaENfF5HX0Ec4dBawdTYiAi-TiG9wi0,1690
 namecheap_dns_tui/__init__.py,sha256=-yL_1Ha41FlQcmjG-raUrZP9CjTJD3d0w2BW2X-twJg,106
@@ -18,8 +19,8 @@ namecheap_dns_tui/assets/screenshot1.png,sha256=OXO2P80ll5WRzLYgaakcNnzos8svlJoX
 namecheap_dns_tui/assets/screenshot2.png,sha256=5VN_qDMNhWEyrOqKw7vxl1h-TgmZQ_V9aph3Xmf_AFg,279194
 namecheap_dns_tui/assets/screenshot3.png,sha256=h39wSKxx1JCkgeAB7Q3_JlBcAtX1vsRFKtWtOwbBVso,220625
 namecheap_dns_tui/assets/screenshot4.png,sha256=J4nCOW16z3vaRiPbcMiiIRgV7q3XFbi_1N1ivD1Pa4Y,238068
-namecheap_python-1.1.0.dist-info/METADATA,sha256=FpJL0AqYw-5ji7oVax8XtfLogWRzY1YvfRMPJlGTgi0,15374
-namecheap_python-1.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-namecheap_python-1.1.0.dist-info/entry_points.txt,sha256=AyhiXroLUpM0Vdo_-RvH0S8o4XDPsDlsEl_65vm6DEk,96
-namecheap_python-1.1.0.dist-info/licenses/LICENSE,sha256=pemTblFP6BBje3bBv_yL_sr2iAqB2H0-LdWMvVIR42o,1062
-namecheap_python-1.1.0.dist-info/RECORD,,
+namecheap_python-1.3.0.dist-info/METADATA,sha256=phjrSgjok2JzRDjOQsEit1eb9Z7WF7Da5beLiKSEbGA,18802
+namecheap_python-1.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+namecheap_python-1.3.0.dist-info/entry_points.txt,sha256=AyhiXroLUpM0Vdo_-RvH0S8o4XDPsDlsEl_65vm6DEk,96
+namecheap_python-1.3.0.dist-info/licenses/LICENSE,sha256=pemTblFP6BBje3bBv_yL_sr2iAqB2H0-LdWMvVIR42o,1062
+namecheap_python-1.3.0.dist-info/RECORD,,