namecheap-python 1.0.6__py3-none-any.whl → 1.2.0__py3-none-any.whl

namecheap/__init__.py

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

namecheap/_api/dns.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any, Literal
 
 import tldextract
 
-from namecheap.models import DNSRecord
+from namecheap.models import DNSRecord, EmailForward, Nameservers
 
 from .base import BaseAPI
 
@@ -381,3 +381,150 @@ class DnsAPI(BaseAPI):
             >>> nc.dns.set("example.com", builder)
         """
         return DNSRecordBuilder()
+
+    def set_custom_nameservers(self, domain: str, nameservers: list[str]) -> bool:
+        """
+        Set custom nameservers for a domain.
+
+        This switches the domain from Namecheap's default DNS to custom
+        nameservers (e.g., Route 53, Cloudflare, etc.).
+
+        Args:
+            domain: Domain name
+            nameservers: List of nameserver hostnames (e.g., ["ns1.example.com", "ns2.example.com"])
+
+        Returns:
+            True if successful
+
+        Examples:
+            >>> nc.dns.set_custom_nameservers("example.com", [
+            ...     "ns-123.awsdns-45.com",
+            ...     "ns-456.awsdns-67.net",
+            ...     "ns-789.awsdns-89.org",
+            ...     "ns-012.awsdns-12.co.uk",
+            ... ])
+        """
+        assert nameservers, "At least one nameserver is required"
+        assert len(nameservers) <= 5, "Maximum of 5 nameservers allowed"
+
+        ext = tldextract.extract(domain)
+        if not ext.domain or not ext.suffix:
+            raise ValueError(f"Invalid domain name: {domain}")
+
+        result: Any = self._request(
+            "namecheap.domains.dns.setCustom",
+            {
+                "SLD": ext.domain,
+                "TLD": ext.suffix,
+                "Nameservers": ",".join(nameservers),
+            },
+            path="DomainDNSSetCustomResult",
+        )
+
+        return bool(result and result.get("@Updated") == "true")
+
+    def set_default_nameservers(self, domain: str) -> bool:
+        """
+        Reset domain to use Namecheap's default nameservers.
+
+        This switches the domain back to Namecheap BasicDNS from custom nameservers.
+
+        Args:
+            domain: Domain name
+
+        Returns:
+            True if successful
+
+        Examples:
+            >>> nc.dns.set_default_nameservers("example.com")
+        """
+        ext = tldextract.extract(domain)
+        if not ext.domain or not ext.suffix:
+            raise ValueError(f"Invalid domain name: {domain}")
+
+        result: Any = self._request(
+            "namecheap.domains.dns.setDefault",
+            {
+                "SLD": ext.domain,
+                "TLD": ext.suffix,
+            },
+            path="DomainDNSSetDefaultResult",
+        )
+
+        return bool(result and result.get("@Updated") == "true")
+
+    def get_nameservers(self, domain: str) -> Nameservers:
+        """
+        Get current nameservers for a domain.
+
+        Args:
+            domain: Domain name
+
+        Returns:
+            Nameservers with is_default flag and nameserver hostnames
+
+        Examples:
+            >>> ns = nc.dns.get_nameservers("example.com")
+            >>> ns.is_default
+            True
+            >>> ns.nameservers
+            ['dns1.registrar-servers.com', 'dns2.registrar-servers.com']
+        """
+        ext = tldextract.extract(domain)
+        if not ext.domain or not ext.suffix:
+            raise ValueError(f"Invalid domain name: {domain}")
+
+        result: Any = self._request(
+            "namecheap.domains.dns.getList",
+            {
+                "SLD": ext.domain,
+                "TLD": ext.suffix,
+            },
+            path="DomainDNSGetListResult",
+        )
+
+        assert result, f"API returned empty result for {domain} nameserver query"
+
+        is_default = result.get("@IsUsingOurDNS", "false").lower() == "true"
+
+        ns_data = result.get("Nameserver", [])
+        assert isinstance(ns_data, str | list), (
+            f"Unexpected Nameserver type: {type(ns_data)}"
+        )
+        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
+        ]

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, DomainInfo
 
 from .base import BaseAPI
 
@@ -110,6 +110,52 @@ 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 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,73 @@ 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."""
+
+    is_default: bool = Field(description="True when using Namecheap's own DNS")
+    nameservers: list[str] = Field(description="Nameserver hostnames")
+
+
 class Contact(BaseModel):
     """Contact information for domain registration."""
 

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]")
@@ -700,6 +674,131 @@ def dns_delete(
         sys.exit(1)
 
 
+@dns_group.command("nameservers")
+@click.argument("domain")
+@pass_config
+def dns_nameservers(config: Config, domain: str) -> None:
+    """Show current nameserver configuration 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 nameserver info for {domain}...", total=None)
+            ns = nc.dns.get_nameservers(domain)
+
+        if config.output_format == "table":
+            console.print(f"\n[bold cyan]Nameservers for {domain}[/bold cyan]\n")
+
+            if ns.is_default:
+                console.print("[green]Using Namecheap BasicDNS[/green]")
+            else:
+                console.print("[yellow]Using custom nameservers:[/yellow]")
+            for nameserver in ns.nameservers:
+                console.print(f"  • {nameserver}")
+        else:
+            output_formatter(ns.model_dump(), config.output_format)
+
+    except NamecheapError as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        sys.exit(1)
+
+
+@dns_group.command("set-nameservers")
+@click.argument("domain")
+@click.argument("nameservers", nargs=-1, required=True)
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation")
+@pass_config
+def dns_set_nameservers(
+    config: Config, domain: str, nameservers: tuple[str, ...], yes: bool
+) -> None:
+    """Set custom nameservers for a domain.
+
+    This switches the domain from Namecheap's default DNS to custom nameservers.
+
+    Example:
+        namecheap-cli dns set-nameservers example.com ns1.route53.com ns2.route53.com
+    """
+    nc = config.init_client()
+
+    try:
+        if not yes and not config.quiet:
+            console.print(
+                f"\n[yellow]Setting custom nameservers for {domain}:[/yellow]"
+            )
+            for ns in nameservers:
+                console.print(f"  • {ns}")
+            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 nameservers for {domain}...", total=None)
+            success = nc.dns.set_custom_nameservers(domain, list(nameservers))
+
+        if success:
+            console.print(f"[green]✅ Custom nameservers set for {domain}[/green]")
+            if not config.quiet:
+                console.print(
+                    "\n[dim]Note: DNS propagation may take up to 48 hours.[/dim]"
+                )
+        else:
+            console.print("[red]❌ Failed to set nameservers[/red]")
+            sys.exit(1)
+
+    except NamecheapError as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        sys.exit(1)
+
+
+@dns_group.command("reset-nameservers")
+@click.argument("domain")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation")
+@pass_config
+def dns_reset_nameservers(config: Config, domain: str, yes: bool) -> None:
+    """Reset domain to use Namecheap's default nameservers.
+
+    This switches the domain back to Namecheap BasicDNS from custom nameservers.
+    """
+    nc = config.init_client()
+
+    try:
+        if not yes and not config.quiet:
+            console.print(
+                f"\n[yellow]This will reset {domain} to Namecheap's default DNS.[/yellow]"
+            )
+            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"Resetting nameservers for {domain}...", total=None)
+            success = nc.dns.set_default_nameservers(domain)
+
+        if success:
+            console.print(f"[green]✅ {domain} is now using Namecheap BasicDNS[/green]")
+        else:
+            console.print("[red]❌ Failed to reset nameservers[/red]")
+            sys.exit(1)
+
+    except NamecheapError as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        sys.exit(1)
+
+
 @dns_group.command("export")
 @click.argument("domain")
 @click.option(
@@ -781,6 +880,45 @@ 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)
+
+
 @cli.group("account")
 def account_group() -> None:
     """Account management commands."""
@@ -791,14 +929,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.0.6.dist-info → namecheap_python-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: namecheap-python
-Version: 1.0.6
+Version: 1.2.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
@@ -302,6 +340,51 @@ nc.dns.set("example.com",
 
 **Note on TTL:** The default TTL is **1799 seconds**, which displays as **"Automatic"** in the Namecheap web interface. This is an undocumented Namecheap API behavior. You can specify custom TTL values (60-86400 seconds) in any DNS method.
 
+### Nameserver Management
+
+```python
+# Check current nameservers
+ns = nc.dns.get_nameservers("example.com")
+print(ns.nameservers)  # ['dns1.registrar-servers.com', 'dns2.registrar-servers.com']
+print(ns.is_default)   # True
+
+# Switch to custom nameservers (e.g., Cloudflare, Route 53)
+nc.dns.set_custom_nameservers("example.com", [
+    "ns1.cloudflare.com",
+    "ns2.cloudflare.com",
+])
+
+# Reset back to Namecheap BasicDNS
+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
+rules = nc.dns.get_email_forwarding("example.com")
+for r in rules:
+    print(f"{r.mailbox} -> {r.forward_to}")
+```
+
 ### Domain Management
 
 ```python
@@ -375,22 +458,24 @@ 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** - Custom nameserver management
-- **Users API** - Account management and balance checking
-- **Whois API** - WHOIS information lookups
-- **Email Forwarding** - Email forwarding configuration
-
-See [pending.md](pending.md) for full details.
+## 📊 [API Coverage](https://www.namecheap.com/support/api/methods/)
+
+| API | Status | Methods |
+|-----|--------|---------|
+| `namecheap.domains.*` | ✅ Done | `check`, `list`, `getInfo`, `register`, `renew`, `setContacts`, `lock`/`unlock` |
+| `namecheap.domains.dns.*` | ✅ Done | `getHosts`, `setHosts` (builder pattern), `add`, `delete`, `export`, `getList`, `setCustom`, `setDefault`, `getEmailForwarding` |
+| `namecheap.users.*` | ⚠️ Partial | `getBalances`, `getPricing` (needs debugging). Planned: `changePassword`, `update`, `create`, `login`, `resetPassword` |
+| `namecheap.domains.*` | 🚧 Planned | `getContacts`, `getTldList`, `reactivate` |
+| `namecheap.domains.dns.*` | 🚧 Planned | `setEmailForwarding` |
+| `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
 
@@ -399,3 +484,9 @@ MIT License - see [LICENSE](LICENSE) file for details.
 ## 🤝 Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request. See the [Development Guide](docs/dev/README.md) for setup instructions and guidelines.
+
+### 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.0.6.dist-info → namecheap_python-1.2.0.dist-info}/RECORD

@@ -1,15 +1,16 @@
-namecheap/__init__.py,sha256=TyOenTWmRyClXBbw1i4vlMc2GRujp6h9tZqjCNBY5l8,666
-namecheap/client.py,sha256=wnhCA5zeZMGypD1uNHbMYCGoP9paaZjtYZucBUsEY6k,6441
+namecheap/__init__.py,sha256=S-84LTSVWDXJeqvDoUoSsq84250m5J0MXYEPJ6xH3kw,837
+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=D_ztY6J816irY8MMj-dx40iFQgar886MmQS8NeV_J18,12115
+namecheap/models.py,sha256=t4xloDJOgKeoERujhMRtTR0-B--ENzQsAn1WyFHyNbE,14261
 namecheap/_api/__init__.py,sha256=ymQxKCySphoeoo4s_J0tLziXttLNhOQ8AZbCzFcuAHs,36
 namecheap/_api/base.py,sha256=FoczO1Q860PaFUFv-S3IoIV2xaGVJAlchkWnmTI6dlw,6121
-namecheap/_api/dns.py,sha256=XJj5E1-4SokWawCit6iZGlvMypxPGjb7COTs4mpNTes,11156
-namecheap/_api/domains.py,sha256=h6cWc03iCwPqOJTfbR8pyom_8MUVPoqSIRJRws1i3UY,16603
+namecheap/_api/dns.py,sha256=MtOHr0AOUgS_Vv7U8WkLBw7xuU0XWbjAF6ptitteNmk,15827
+namecheap/_api/domains.py,sha256=bEPshE2GN6ubd0otTwLdZCpKVT9ErmDRy8fYxS2hkIY,18272
+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=-936gBbkwqbCTLM6c_eQdZRLH6NwtC9vywnmWfRAyzw,30814
+namecheap_cli/__main__.py,sha256=ZOmdVQZWkA3SHw7_nGCp_j5RdJCQff4NO6h_nIjgDnY,36425
 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.0.6.dist-info/METADATA,sha256=fOcbCkiglpU6fan-t0STKQT5sVg8VDhXmsvRV0y8IRs,14802
-namecheap_python-1.0.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-namecheap_python-1.0.6.dist-info/entry_points.txt,sha256=AyhiXroLUpM0Vdo_-RvH0S8o4XDPsDlsEl_65vm6DEk,96
-namecheap_python-1.0.6.dist-info/licenses/LICENSE,sha256=pemTblFP6BBje3bBv_yL_sr2iAqB2H0-LdWMvVIR42o,1062
-namecheap_python-1.0.6.dist-info/RECORD,,
+namecheap_python-1.2.0.dist-info/METADATA,sha256=R44Jl31VrMFE8lzs_YxqgGuv7sHvN0rIj9qjgdvKyv0,18433
+namecheap_python-1.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+namecheap_python-1.2.0.dist-info/entry_points.txt,sha256=AyhiXroLUpM0Vdo_-RvH0S8o4XDPsDlsEl_65vm6DEk,96
+namecheap_python-1.2.0.dist-info/licenses/LICENSE,sha256=pemTblFP6BBje3bBv_yL_sr2iAqB2H0-LdWMvVIR42o,1062
+namecheap_python-1.2.0.dist-info/RECORD,,

{namecheap_python-1.0.6.dist-info → namecheap_python-1.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any