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

namecheap/__init__.py

@@ -22,9 +22,11 @@ from .models import (
     DomainInfo,
     EmailForward,
     Nameservers,
+    Tld,
+    WhoisguardEntry,
 )
 
-__version__ = "1.3.0"
+__version__ = "1.4.0"
 __all__ = [
     "AccountBalance",
     "ConfigurationError",
@@ -38,5 +40,7 @@ __all__ = [
     "Namecheap",
     "NamecheapError",
     "Nameservers",
+    "Tld",
     "ValidationError",
+    "WhoisguardEntry",
 ]

namecheap/_api/domains.py

@@ -9,7 +9,14 @@ from typing import Any
 import tldextract
 
 from namecheap.logging import logger
-from namecheap.models import Contact, Domain, DomainCheck, DomainContacts, DomainInfo
+from namecheap.models import (
+    Contact,
+    Domain,
+    DomainCheck,
+    DomainContacts,
+    DomainInfo,
+    Tld,
+)
 
 from .base import BaseAPI
 
@@ -202,6 +209,34 @@ class DomainsAPI(BaseAPI):
             aux_billing=parse_contact(result.get("AuxBilling", {})),
         )
 
+    def get_tld_list(self) -> builtins.list[Tld]:
+        """
+        Get list of all TLDs supported by Namecheap.
+
+        NOTE: Cache this response — it rarely changes and the API docs recommend it.
+
+        Returns:
+            List of Tld objects with registration/renewal constraints and capabilities
+
+        Examples:
+            >>> tlds = nc.domains.get_tld_list()
+            >>> registerable = [t for t in tlds if t.is_api_registerable]
+            >>> print(f"{len(registerable)} TLDs available for API registration")
+        """
+        result: Any = self._request(
+            "namecheap.domains.getTldList",
+            path="Tlds",
+        )
+
+        assert result, "API returned empty result for getTldList"
+
+        tlds = result.get("Tld", [])
+        if isinstance(tlds, dict):
+            tlds = [tlds]
+        assert isinstance(tlds, list), f"Unexpected Tld type: {type(tlds)}"
+
+        return [Tld.model_validate(t) for t in tlds]
+
     def register(
         self,
         domain: str,

namecheap/_api/whoisguard.py

@@ -0,0 +1,195 @@
+"""Domain privacy (WhoisGuard) API."""
+
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any, Literal
+
+from namecheap.models import WhoisguardEntry
+
+from .base import BaseAPI
+
+
+class WhoisguardAPI(BaseAPI):
+    """Domain privacy (WhoisGuard) management.
+
+    The Namecheap API uses WhoisGuard IDs internally, but this class
+    provides domain-name-based convenience methods that resolve the ID
+    automatically via get_list().
+    """
+
+    def get_list(
+        self,
+        *,
+        list_type: Literal["ALL", "ALLOTED", "FREE", "DISCARD"] = "ALL",
+        page: int = 1,
+        page_size: int = 100,
+    ) -> list[WhoisguardEntry]:
+        """
+        Get all WhoisGuard subscriptions.
+
+        Args:
+            list_type: Filter type (ALL, ALLOTED, FREE, DISCARD)
+            page: Page number
+            page_size: Items per page (2-100)
+
+        Returns:
+            List of WhoisguardEntry subscriptions
+
+        Examples:
+            >>> entries = nc.whoisguard.get_list()
+            >>> for e in entries:
+            ...     print(f"{e.domain} (ID={e.id}) status={e.status}")
+        """
+        result: Any = self._request(
+            "namecheap.whoisguard.getList",
+            {
+                "ListType": list_type,
+                "Page": page,
+                "PageSize": min(page_size, 100),
+            },
+            path="WhoisguardGetListResult",
+        )
+
+        if not result:
+            return []
+
+        entries = result.get("Whoisguard", [])
+        if isinstance(entries, dict):
+            entries = [entries]
+        assert isinstance(entries, list), f"Unexpected Whoisguard type: {type(entries)}"
+
+        return [WhoisguardEntry.model_validate(e) for e in entries]
+
+    def _resolve_id(self, domain: str) -> int:
+        """Resolve a domain name to its WhoisGuard ID."""
+        entries = self.get_list(list_type="ALLOTED")
+        for entry in entries:
+            if entry.domain.lower() == domain.lower():
+                return entry.id
+        raise ValueError(
+            f"No WhoisGuard subscription found for {domain}. "
+            f"Domain must have WhoisGuard allotted to enable/disable it."
+        )
+
+    def enable(self, domain: str, forwarded_to_email: str) -> bool:
+        """
+        Enable domain privacy for a domain.
+
+        Args:
+            domain: Domain name (resolved to WhoisGuard ID automatically)
+            forwarded_to_email: Email where privacy-masked emails get forwarded
+
+        Returns:
+            True if successful
+
+        Examples:
+            >>> nc.whoisguard.enable("example.com", "me@gmail.com")
+        """
+        wg_id = self._resolve_id(domain)
+
+        result: Any = self._request(
+            "namecheap.whoisguard.enable",
+            {
+                "WhoisguardID": wg_id,
+                "ForwardedToEmail": forwarded_to_email,
+            },
+            path="WhoisguardEnableResult",
+        )
+
+        assert result, f"API returned empty result for whoisguard.enable on {domain}"
+        return result.get("@IsSuccess", "false").lower() == "true"
+
+    def disable(self, domain: str) -> bool:
+        """
+        Disable domain privacy for a domain.
+
+        Args:
+            domain: Domain name (resolved to WhoisGuard ID automatically)
+
+        Returns:
+            True if successful
+
+        Examples:
+            >>> nc.whoisguard.disable("example.com")
+        """
+        wg_id = self._resolve_id(domain)
+
+        result: Any = self._request(
+            "namecheap.whoisguard.disable",
+            {"WhoisguardID": wg_id},
+            path="WhoisguardDisableResult",
+        )
+
+        assert result, f"API returned empty result for whoisguard.disable on {domain}"
+        return result.get("@IsSuccess", "false").lower() == "true"
+
+    def renew(self, domain: str, *, years: int = 1) -> dict[str, Any]:
+        """
+        Renew domain privacy for a domain.
+
+        Args:
+            domain: Domain name (resolved to WhoisGuard ID automatically)
+            years: Number of years to renew (1-9)
+
+        Returns:
+            Dict with OrderId, TransactionId, ChargedAmount
+
+        Examples:
+            >>> result = nc.whoisguard.renew("example.com", years=1)
+            >>> print(f"Charged: {result['charged_amount']}")
+        """
+        assert 1 <= years <= 9, "Years must be between 1 and 9"
+        wg_id = self._resolve_id(domain)
+
+        result: Any = self._request(
+            "namecheap.whoisguard.renew",
+            {
+                "WhoisguardID": wg_id,
+                "Years": years,
+            },
+            path="WhoisguardRenewResult",
+        )
+
+        assert result, f"API returned empty result for whoisguard.renew on {domain}"
+        return {
+            "whoisguard_id": int(result.get("@WhoisguardId", wg_id)),
+            "years": int(result.get("@Years", years)),
+            "is_renewed": result.get("@Renew", "false").lower() == "true",
+            "order_id": int(result.get("@OrderId", 0)),
+            "transaction_id": int(result.get("@TransactionId", 0)),
+            "charged_amount": Decimal(result.get("@ChargedAmount", "0")),
+        }
+
+    def change_email(self, domain: str) -> dict[str, str]:
+        """
+        Rotate the privacy forwarding email address for a domain.
+
+        Namecheap generates a new masked email and retires the old one.
+        No input email needed — the API handles the rotation.
+
+        Args:
+            domain: Domain name (resolved to WhoisGuard ID automatically)
+
+        Returns:
+            Dict with new_email and old_email
+
+        Examples:
+            >>> result = nc.whoisguard.change_email("example.com")
+            >>> print(f"New: {result['new_email']}")
+        """
+        wg_id = self._resolve_id(domain)
+
+        result: Any = self._request(
+            "namecheap.whoisguard.changeEmailAddress",
+            {"WhoisguardID": wg_id},
+            path="WhoisguardChangeEmailAddressResult",
+        )
+
+        assert result, (
+            f"API returned empty result for whoisguard.changeEmailAddress on {domain}"
+        )
+        return {
+            "new_email": result.get("@WGEmail", ""),
+            "old_email": result.get("@WGOldEmail", ""),
+        }

namecheap/client.py

@@ -17,6 +17,7 @@ if TYPE_CHECKING:
     from ._api.dns import DnsAPI
     from ._api.domains import DomainsAPI
     from ._api.users import UsersAPI
+    from ._api.whoisguard import WhoisguardAPI
 
 
 class Namecheap:
@@ -111,6 +112,13 @@ class Namecheap:
 
         return DnsAPI(self)
 
+    @cached_property
+    def whoisguard(self) -> WhoisguardAPI:
+        """Domain privacy (WhoisGuard) management."""
+        from ._api.whoisguard import WhoisguardAPI
+
+        return WhoisguardAPI(self)
+
     @cached_property
     def users(self) -> UsersAPI:
         """User account operations."""

namecheap/models.py

@@ -347,6 +347,82 @@ class DomainContacts(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
 
 
+class Tld(BaseModel):
+    """TLD information from Namecheap's supported TLD list."""
+
+    name: str = Field(alias="@Name")
+    description: str = Field(alias="#text", default="")
+    type: str = Field(alias="@Type")
+    min_register_years: int = Field(alias="@MinRegisterYears")
+    max_register_years: int = Field(alias="@MaxRegisterYears")
+    min_renew_years: int = Field(alias="@MinRenewYears")
+    max_renew_years: int = Field(alias="@MaxRenewYears")
+    min_transfer_years: int = Field(alias="@MinTransferYears")
+    max_transfer_years: int = Field(alias="@MaxTransferYears")
+    is_api_registerable: bool = Field(alias="@IsApiRegisterable")
+    is_api_renewable: bool = Field(alias="@IsApiRenewable")
+    is_api_transferable: bool = Field(alias="@IsApiTransferable")
+    is_epp_required: bool = Field(alias="@IsEppRequired")
+    is_disable_mod_contact: bool = Field(alias="@IsDisableModContact")
+    is_disable_wg_allot: bool = Field(alias="@IsDisableWGAllot")
+    is_supports_idn: bool = Field(alias="@IsSupportsIDN")
+    category: str = Field(alias="@Category", default="")
+    sequence_number: int = Field(alias="@SequenceNumber", default=0)
+    non_real_time: bool = Field(alias="@NonRealTime", default=False)
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    @field_validator(
+        "is_api_registerable",
+        "is_api_renewable",
+        "is_api_transferable",
+        "is_epp_required",
+        "is_disable_mod_contact",
+        "is_disable_wg_allot",
+        "is_supports_idn",
+        "non_real_time",
+        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
+
+    @field_validator(
+        "min_register_years",
+        "max_register_years",
+        "min_renew_years",
+        "max_renew_years",
+        "min_transfer_years",
+        "max_transfer_years",
+        "sequence_number",
+        mode="before",
+    )
+    @classmethod
+    def parse_int(cls, v: Any) -> int:
+        return int(v) if v else 0
+
+
+class WhoisguardEntry(BaseModel):
+    """A WhoisGuard/domain privacy subscription."""
+
+    id: int = Field(alias="@ID")
+    domain: str = Field(alias="@DomainName", default="")
+    created: str = Field(alias="@Created", default="")
+    expires: str = Field(alias="@Expires", default="")
+    status: str = Field(alias="@Status", default="")
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    @field_validator("id", mode="before")
+    @classmethod
+    def parse_id(cls, v: Any) -> int:
+        return int(v) if v else 0
+
+
 class Config(BaseModel):
     """Client configuration with validation."""
 

namecheap_cli/__main__.py

@@ -1016,6 +1016,293 @@ def domain_contacts(config: Config, domain: str) -> None:
         sys.exit(1)
 
 
+@domain_group.command("tlds")
+@click.option("--registerable", is_flag=True, help="Only show API-registerable TLDs")
+@click.option(
+    "--type",
+    "-t",
+    "tld_type",
+    type=click.Choice(["GTLD", "CCTLD"], case_sensitive=False),
+    help="Filter by TLD type",
+)
+@pass_config
+def domain_tlds(config: Config, registerable: bool, tld_type: str | None) -> None:
+    """List all supported TLDs."""
+    nc = config.init_client()
+
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task("Loading TLD list...", total=None)
+            tlds = nc.domains.get_tld_list()
+
+        if registerable:
+            tlds = [t for t in tlds if t.is_api_registerable]
+        if tld_type:
+            tlds = [t for t in tlds if t.type.upper() == tld_type.upper()]
+
+        tlds.sort(key=lambda t: t.name)
+
+        if config.output_format == "table":
+            table = Table(title=f"Supported TLDs ({len(tlds)} total)")
+            table.add_column("TLD", style="cyan")
+            table.add_column("Type", style="magenta")
+            table.add_column("Description", style="dim")
+            table.add_column("Register", justify="center")
+            table.add_column("Renew", justify="center")
+            table.add_column("Transfer", justify="center")
+            table.add_column("Years", justify="center")
+
+            for t in tlds:
+                table.add_row(
+                    f".{t.name}",
+                    t.type,
+                    t.description[:40] if t.description else "",
+                    "✓" if t.is_api_registerable else "✗",
+                    "✓" if t.is_api_renewable else "✗",
+                    "✓" if t.is_api_transferable else "✗",
+                    f"{t.min_register_years}-{t.max_register_years}",
+                )
+
+            console.print(table)
+        else:
+            data = [
+                {
+                    "tld": t.name,
+                    "type": t.type,
+                    "description": t.description,
+                    "api_registerable": t.is_api_registerable,
+                    "api_renewable": t.is_api_renewable,
+                    "api_transferable": t.is_api_transferable,
+                }
+                for t in tlds
+            ]
+            output_formatter(data, config.output_format)
+
+    except NamecheapError as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        sys.exit(1)
+
+
+@cli.group("privacy")
+def privacy_group() -> None:
+    """Domain privacy (WhoisGuard) management."""
+    pass
+
+
+@privacy_group.command("list")
+@click.option(
+    "--type",
+    "-t",
+    "list_type",
+    type=click.Choice(["ALL", "ALLOTED", "FREE", "DISCARD"], case_sensitive=False),
+    default="ALL",
+    help="Filter by subscription type",
+)
+@pass_config
+def privacy_list(config: Config, list_type: str) -> None:
+    """List WhoisGuard subscriptions."""
+    nc = config.init_client()
+
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task("Loading WhoisGuard subscriptions...", total=None)
+            entries = nc.whoisguard.get_list(list_type=list_type.upper())
+
+        if config.output_format == "table":
+            table = Table(title=f"WhoisGuard Subscriptions ({len(entries)} total)")
+            table.add_column("ID", style="dim")
+            table.add_column("Domain", style="cyan")
+            table.add_column("Status", style="green")
+            table.add_column("Created", style="yellow")
+            table.add_column("Expires", style="yellow")
+
+            for e in entries:
+                status_style = (
+                    "green" if e.status.lower() in ("enabled", "alloted") else "yellow"
+                )
+                table.add_row(
+                    str(e.id),
+                    e.domain or "[dim]unassigned[/dim]",
+                    f"[{status_style}]{e.status}[/{status_style}]",
+                    e.created,
+                    e.expires,
+                )
+
+            console.print(table)
+        else:
+            output_formatter([e.model_dump() for e in entries], config.output_format)
+
+    except NamecheapError as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        sys.exit(1)
+
+
+@privacy_group.command("enable")
+@click.argument("domain")
+@click.argument("email")
+@pass_config
+def privacy_enable(config: Config, domain: str, email: str) -> None:
+    """Enable domain privacy. Requires forwarding email.
+
+    Example:
+        namecheap-cli privacy enable example.com me@gmail.com
+    """
+    nc = config.init_client()
+
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(f"Enabling privacy for {domain}...", total=None)
+            success = nc.whoisguard.enable(domain, email)
+
+        if success:
+            console.print(f"[green]✅ Privacy enabled for {domain}[/green]")
+            console.print(f"[dim]Forwarding email: {email}[/dim]")
+        else:
+            console.print("[red]❌ Failed to enable privacy[/red]")
+            sys.exit(1)
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        sys.exit(1)
+    except NamecheapError as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        sys.exit(1)
+
+
+@privacy_group.command("disable")
+@click.argument("domain")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation")
+@pass_config
+def privacy_disable(config: Config, domain: str, yes: bool) -> None:
+    """Disable domain privacy.
+
+    Example:
+        namecheap-cli privacy disable example.com
+    """
+    nc = config.init_client()
+
+    try:
+        if not yes and not config.quiet:
+            console.print(
+                f"\n[yellow]This will expose your WHOIS information for {domain}.[/yellow]"
+            )
+            if not Confirm.ask("Continue?", default=False):
+                console.print("[yellow]Cancelled[/yellow]")
+                return
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(f"Disabling privacy for {domain}...", total=None)
+            success = nc.whoisguard.disable(domain)
+
+        if success:
+            console.print(f"[green]✅ Privacy disabled for {domain}[/green]")
+        else:
+            console.print("[red]❌ Failed to disable privacy[/red]")
+            sys.exit(1)
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        sys.exit(1)
+    except NamecheapError as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        sys.exit(1)
+
+
+@privacy_group.command("renew")
+@click.argument("domain")
+@click.option("--years", "-y", type=int, default=1, help="Years to renew (1-9)")
+@click.option("--yes", is_flag=True, help="Skip confirmation")
+@pass_config
+def privacy_renew(config: Config, domain: str, years: int, yes: bool) -> None:
+    """Renew domain privacy subscription.
+
+    Example:
+        namecheap-cli privacy renew example.com --years 2
+    """
+    nc = config.init_client()
+
+    try:
+        if not yes and not config.quiet:
+            console.print(
+                f"\n[yellow]Renewing WhoisGuard for {domain} ({years} year{'s' if years > 1 else ''}).[/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"Renewing privacy for {domain}...", total=None)
+            result = nc.whoisguard.renew(domain, years=years)
+
+        if result["is_renewed"]:
+            console.print(f"[green]✅ Privacy renewed for {domain}[/green]")
+            console.print(f"[dim]Charged: {result['charged_amount']}[/dim]")
+        else:
+            console.print("[red]❌ Failed to renew privacy[/red]")
+            sys.exit(1)
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        sys.exit(1)
+    except NamecheapError as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        sys.exit(1)
+
+
+@privacy_group.command("change-email")
+@click.argument("domain")
+@pass_config
+def privacy_change_email(config: Config, domain: str) -> None:
+    """Rotate the privacy forwarding email address.
+
+    Namecheap generates a new masked email automatically.
+
+    Example:
+        namecheap-cli privacy change-email example.com
+    """
+    nc = config.init_client()
+
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(f"Rotating privacy email for {domain}...", total=None)
+            result = nc.whoisguard.change_email(domain)
+
+        console.print(f"[green]✅ Privacy email rotated for {domain}[/green]")
+        console.print(f"  New: {result['new_email']}")
+        console.print(f"  Old: {result['old_email']}")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        sys.exit(1)
+    except NamecheapError as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        sys.exit(1)
+
+
 @cli.group("account")
 def account_group() -> None:
     """Account management commands."""

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: namecheap-python
-Version: 1.3.0
+Version: 1.4.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
@@ -400,6 +400,41 @@ print(f"{contacts.registrant.first_name} {contacts.registrant.last_name}")
 print(contacts.registrant.email)
 ```
 
+### TLD List
+
+```python
+tlds = nc.domains.get_tld_list()
+print(f"{len(tlds)} TLDs supported")
+
+# Filter to API-registerable TLDs
+registerable = [t for t in tlds if t.is_api_registerable]
+for t in registerable[:5]:
+    print(f".{t.name} ({t.type}) — {t.min_register_years}-{t.max_register_years} years")
+```
+
+### Domain Privacy (WhoisGuard)
+
+```python
+# List all WhoisGuard subscriptions
+entries = nc.whoisguard.get_list()
+for e in entries:
+    print(f"{e.domain} (ID={e.id}) status={e.status}")
+
+# Enable privacy (resolves WhoisGuard ID from domain name automatically)
+nc.whoisguard.enable("example.com", "me@gmail.com")
+
+# Disable privacy
+nc.whoisguard.disable("example.com")
+
+# Renew privacy
+result = nc.whoisguard.renew("example.com", years=1)
+print(f"Charged: {result['charged_amount']}")
+
+# Rotate the masked forwarding email
+result = nc.whoisguard.change_email("example.com")
+print(f"New: {result['new_email']}")
+```
+
 ### Domain Management
 
 ```python
@@ -461,6 +496,15 @@ except NamecheapError as e:
 
 This section documents undocumented or unusual Namecheap API behaviors we've discovered:
 
+### No WHOIS lookups or Marketplace data
+
+The Namecheap API only operates on domains **in your account**. There is no API for:
+- WHOIS lookups on arbitrary domains
+- Checking if a domain is listed on [Namecheap Marketplace](https://www.namecheap.com/domains/marketplace/)
+- Aftermarket pricing or availability
+
+`domains.check()` tells you if a domain is **unregistered**, not if it's for sale by its owner.
+
 ### TTL "Automatic" = 1799 seconds
 
 The Namecheap web interface displays TTL as **"Automatic"** when the value is exactly **1799 seconds**, but shows **"30 min"** when it's **1800 seconds**. This behavior is completely undocumented in their official API documentation.
@@ -477,15 +521,15 @@ nc.dns.builder().a("www", "192.0.2.1", ttl=1800)  # Shows as "30 min"
 
 | API | Status | Methods |
 |-----|--------|---------|
-| `namecheap.domains.*` | ✅ Done | `check`, `list`, `getInfo`, `getContacts`, `register`, `renew`, `setContacts`, `lock`/`unlock` |
+| `namecheap.domains.*` | ✅ Done | `check`, `list`, `getInfo`, `getContacts`, `getTldList`, `register`, `renew`, `setContacts`, `lock`/`unlock` |
 | `namecheap.domains.dns.*` | ✅ Done | `getHosts`, `setHosts` (builder pattern), `add`, `delete`, `export`, `getList`, `setCustom`, `setDefault`, `getEmailForwarding`, `setEmailForwarding` |
+| `namecheap.whoisguard.*` | ✅ Done | `getList`, `enable`, `disable`, `renew`, `changeEmailAddress` |
 | `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` |
+| `namecheap.domains.*` | 🚧 Planned | `reactivate` |
 
 ## 🛠️ Development
 
@@ -497,7 +541,7 @@ 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.
+Contributions are welcome! Please feel free to submit a Pull Request. See [CONTRIBUTING.md](CONTRIBUTING.md) for setup instructions and guidelines.
 
 ### Contributors
 

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

@@ -1,16 +1,17 @@
-namecheap/__init__.py,sha256=sUX2-G_o6k1POjfJ9oV32Hi08zaPNL4WwfgrLr_2Qak,879
-namecheap/client.py,sha256=KesIaZVa9HpXvlp-hc3nr2x-sqzMPiHEa8NibiPq580,6644
+namecheap/__init__.py,sha256=d4na6bJ0UVqU2CUBwP5eROrinnD92qpFBNHn8l6IAxo,943
+namecheap/client.py,sha256=c-JxBygXjD62bcTDzD9jv8hzd9K-C4TzzSoQQxT7H6I,6897
 namecheap/errors.py,sha256=5bGbV1e4_jkK8YXZXbLF6GJCVUTKw1CtMl9-mz7ogZg,5010
 namecheap/logging.py,sha256=lMR1fr1dWWz3z2NFEY-vl8b52FmmhH76R2NjyifSdYA,3396
-namecheap/models.py,sha256=0Fhni7yKd84bBopPURIvhwmOCYMzw8tlZwHWzRRZphY,14494
+namecheap/models.py,sha256=Rz6wc-6uQJPI-i1eALorRRjiTs9-XRhqGsEiD0jFVfg,17130
 namecheap/_api/__init__.py,sha256=ymQxKCySphoeoo4s_J0tLziXttLNhOQ8AZbCzFcuAHs,36
 namecheap/_api/base.py,sha256=FoczO1Q860PaFUFv-S3IoIV2xaGVJAlchkWnmTI6dlw,6121
 namecheap/_api/dns.py,sha256=Hny5TsVWmmG-3rF6kb8JwboGFt2wKsd4-Z6T8GannBM,17213
-namecheap/_api/domains.py,sha256=txikTYACM82-3IXg2Gqagh9fRZ8aIZiu05unNpy2Zqs,20039
+namecheap/_api/domains.py,sha256=fo9JBsKtPlqme_nkEw8KseQ93STnH2Nn744669rn7TA,21030
 namecheap/_api/users.py,sha256=CCXSZJiPkQiLHYRAlYKTBCDG3-JSPdNkNWWww71JXV0,795
+namecheap/_api/whoisguard.py,sha256=R7jBiWlFqxu0EKwtayJEFHZwqub2ELd6pziaiQvxvd8,6207
 namecheap_cli/README.md,sha256=liduIiGr8DHXGTht5swrYnvtAlcdCMQOnSdCD61g4Vw,7337
 namecheap_cli/__init__.py,sha256=nGRHc_CkO4xKhSQdAVG-koEffP8VS0TvbfbZkg7Jg4k,108
-namecheap_cli/__main__.py,sha256=0vHk5aAhEzPKQ-UQOQdYqsolCF13DG3k9_z3pUbZXwk,40020
+namecheap_cli/__main__.py,sha256=V4qNuZfsLYHmjQV9awjG4ZvBusiUf_lkQcFP9I1ulx8,49629
 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
@@ -19,8 +20,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.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,,
+namecheap_python-1.4.0.dist-info/METADATA,sha256=mJMPACBtcu8-nOEIArjlR52KYdPub1ZdkOTavx5GvN0,20120
+namecheap_python-1.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+namecheap_python-1.4.0.dist-info/entry_points.txt,sha256=AyhiXroLUpM0Vdo_-RvH0S8o4XDPsDlsEl_65vm6DEk,96
+namecheap_python-1.4.0.dist-info/licenses/LICENSE,sha256=pemTblFP6BBje3bBv_yL_sr2iAqB2H0-LdWMvVIR42o,1062
+namecheap_python-1.4.0.dist-info/RECORD,,