@fwgapps/namecheap 0.6.0 → 1.0.0

package/dist/index.d.ts

@@ -1,26 +1,220 @@
-interface ConfigType {
-    apiUser: string;
-    apiKey: string;
-    clientIp: string;
-    sandbox: boolean;
-    username?: string;
+interface XmlNode {
+    readonly name: string;
+    readonly attrs: Readonly<Record<string, string>>;
+    readonly text: string;
+    readonly children: readonly XmlNode[];
+}
+
+/** Typed, read-only view over an XML node. Error messages never include attribute values. */
+declare class El {
+    private readonly node;
+    readonly name: string;
+    constructor(node: XmlNode);
+    text(): string;
+    all(name: string): El[];
+    /** All direct child elements in document order, whatever their names. */
+    children(): El[];
+    /** Text of the first child element called `name`, or `undefined` when there is none. */
+    optionalText(name: string): string | undefined;
+    one(name: string): El;
+    optional(name: string): El | undefined;
+    string(attr: string): string;
+    optionalString(attr: string): string | undefined;
+    number(attr: string): number;
+    optionalNumber(attr: string): number | undefined;
+    boolean(attr: string): boolean;
+    optionalBoolean(attr: string): boolean | undefined;
+    /**
+     * Never throws: the plain decimal value of an attribute, or `undefined` when it is
+     * absent or not acceptable. For undocumented responses of billed or account-changing
+     * commands, where a parse failure after the action succeeded would invite a retry.
+     */
+    lenientNumber(attr: string): number | undefined;
+    /** Never throws: `true`/`false` (any case), or `undefined` when absent or anything else. */
+    lenientBoolean(attr: string): boolean | undefined;
+    /** Element text as a plain decimal number (for numeric child elements). */
+    numberText(): number;
+    /** Element text as `true`/`false` (for boolean child elements). */
+    booleanText(): boolean;
+    attributes(): Record<string, string>;
+    private parseNumber;
+    private parseBoolean;
 }
-interface NamecheapProps {
+
+type ArrayStyle = "bracket" | "suffix";
+
+interface TransportConfig {
     apiUser: string;
     apiKey: string;
+    userName?: string;
     clientIp: string;
-    apiUrl: string;
-    username: string;
+    sandbox?: boolean;
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+}
+interface CommandRequest {
+    command: string;
+    params: Array<[string, string]>;
+}
+type Send = (req: CommandRequest) => Promise<El>;
+/**
+ * Creates the function that sends one command as a form-encoded POST and returns the
+ * `CommandResponse` element. Error messages are fixed strings: they never contain the
+ * URL, the API key, the request body or the response body.
+ */
+declare function createTransport(config: TransportConfig): Send;
+
+interface CommandDef<P, R> {
+    /** Namecheap command name, e.g. `namecheap.domains.check`. */
+    name: string;
+    arrayStyle?: ArrayStyle;
+    /** Maps a dotted camelCase path to an exact parameter name. */
+    keys?: Readonly<Record<string, string>>;
+    /** Runs before serializing; throw to reject the call without sending anything. */
+    validate?: (params: P) => void;
+    /** Receives the CommandResponse element returned by `send`. */
+    parse: (cr: El) => R;
+}
+interface Command<P, R> extends CommandDef<P, R> {
+    /** Phantom field carrying the params type; never set at runtime. */
+    readonly _params?: P;
+}
+type Group<C> = {
+    [K in keyof C]: C[K] extends Command<infer P, infer R> ? {} extends P ? (params?: P) => Promise<R> : (params: P) => Promise<R> : never;
+};
+/**
+ * Runs one command: validates, serializes, sends and parses.
+ *
+ * This is the tree-shakeable entry point: importing only `createTransport`, one
+ * standalone command (for example `domainsCheck`) and `run` bundles just those, not the
+ * whole command catalog that `new Namecheap(...)` carries.
+ */
+declare function run<P, R>(command: Command<P, R>, send: Send, ...args: {} extends P ? [params?: P] : [params: P]): Promise<R>;
+
+declare class Namecheap {
+    readonly domains: Group<{
+        getList: Command<DomainsGetListParams, DomainsGetListResult>;
+        check: Command<DomainsCheckParams, DomainsCheckResult>;
+        getRegistrarLock: Command<DomainsGetRegistrarLockParams, DomainsGetRegistrarLockResult>;
+        setRegistrarLock: Command<DomainsSetRegistrarLockParams, DomainsSetRegistrarLockResult>;
+        reactivate: Command<DomainsReactivateParams, DomainsReactivateResult>;
+        renew: Command<DomainsRenewParams, DomainsRenewResult>;
+        setContacts: Command<DomainsSetContactsParams, DomainsSetContactsResult>;
+        create: Command<DomainsCreateParams, DomainsCreateResult>;
+        getTldList: Command<Record<string, never>, DomainsGetTldListResult>;
+        getContacts: Command<DomainsGetContactsParams, DomainsGetContactsResult>;
+        getInfo: Command<DomainsGetInfoParams, DomainsGetInfoResult>;
+    }>;
+    readonly dns: Group<{
+        setDefault: Command<DnsSetDefaultParams, DnsSetDefaultResult>;
+        setCustom: Command<DnsSetCustomParams, DnsSetCustomResult>;
+        getList: Command<DnsGetListParams, DnsGetListResult>;
+        getHosts: Command<DnsGetHostsParams, DnsGetHostsResult>;
+        getEmailForwarding: Command<DnsGetEmailForwardingParams, DnsGetEmailForwardingResult>;
+        setEmailForwarding: Command<DnsSetEmailForwardingParams, DnsSetEmailForwardingResult>;
+        setHosts: Command<DnsSetHostsParams, DnsSetHostsResult>;
+    }>;
+    readonly ns: Group<{
+        create: Command<NsCreateParams, NsCreateResult>;
+        delete: Command<NsDeleteParams, NsDeleteResult>;
+        getInfo: Command<NsGetInfoParams, NsGetInfoResult>;
+        update: Command<NsUpdateParams, NsUpdateResult>;
+    }>;
+    readonly transfer: Group<{
+        create: Command<TransferCreateParams, TransferCreateResult>;
+        getStatus: Command<TransferGetStatusParams, TransferGetStatusResult>;
+        updateStatus: Command<TransferUpdateStatusParams, TransferUpdateStatusResult>;
+        getList: Command<TransferGetListParams, TransferGetListResult>;
+    }>;
+    readonly ssl: Group<{
+        create: Command<SslCreateParams, SslCreateResult>;
+        getList: Command<SslGetListParams, SslGetListResult>;
+        parseCSR: Command<SslParseCsrParams, SslParseCsrResult>;
+        getApproverEmailList: Command<SslGetApproverEmailListParams, SslGetApproverEmailListResult>;
+        activate: Command<SslActivateParams, SslActivateResult>;
+        resendApproverEmail: Command<SslResendApproverEmailParams, SslResendResult>;
+        reissue: Command<SslReissueParams, SslActivateResult>;
+        resendFulfillmentEmail: Command<SslResendFulfillmentEmailParams, SslResendResult>;
+        editDCVMethod: Command<SslEditDcvMethodParams, SslActivateResult>;
+        getInfo: Command<SslGetInfoParams, SslGetInfoResult>;
+        renew: Command<SslRenewParams, SslRenewResult>;
+        purchaseMoreSans: Command<SslPurchaseMoreSansParams, SslPurchaseMoreSansResult>;
+        revokeCertificate: Command<SslRevokeCertificateParams, SslRevokeCertificateResult>;
+    }>;
+    readonly users: Group<{
+        getBalances: Command<Record<string, never>, UsersGetBalancesResult>;
+        getPricing: Command<UsersGetPricingParams, UsersGetPricingResult>;
+        changePassword: Command<UsersChangePasswordParams, UsersChangePasswordResult>;
+        update: Command<UsersUpdateParams, UsersUpdateResult>;
+        createAddFundsRequest: Command<UsersCreateAddFundsRequestParams, UsersCreateAddFundsRequestResult>;
+        getAddFundsStatus: Command<UsersGetAddFundsStatusParams, UsersGetAddFundsStatusResult>;
+        create: Command<UsersCreateParams, UsersCreateResult>;
+        login: Command<UsersLoginParams, UsersLoginResult>;
+        resetPassword: Command<UsersResetPasswordParams, UsersResetPasswordResult>;
+    }>;
+    readonly usersAddress: Group<{
+        create: Command<UsersAddressCreateParams, UsersAddressCreateResult>;
+        delete: Command<UsersAddressDeleteParams, UsersAddressDeleteResult>;
+        getInfo: Command<UsersAddressGetInfoParams, UsersAddressGetInfoResult>;
+        getList: Command<Record<string, never>, UsersAddressGetListResult>;
+        setDefault: Command<UsersAddressSetDefaultParams, UsersAddressSetDefaultResult>;
+        update: Command<UsersAddressUpdateParams, UsersAddressUpdateResult>;
+    }>;
+    readonly whoisGuard: Group<{
+        changeEmailAddress: Command<WhoisguardChangeEmailAddressParams, WhoisguardChangeEmailAddressResult>;
+        enable: Command<WhoisguardEnableParams, WhoisguardEnableResult>;
+        disable: Command<WhoisguardDisableParams, WhoisguardDisableResult>;
+        getList: Command<WhoisguardGetListParams, WhoisguardGetListResult>;
+        renew: Command<WhoisguardRenewParams, WhoisguardRenewResult>;
+    }>;
+    constructor(config: TransportConfig);
+}
+
+type ApiErrorItem = {
+    code: number;
+    message: string;
+};
+/** Thrown when the Namecheap API answers with `Status="ERROR"`. */
+declare class NamecheapError extends Error {
+    readonly code: number;
+    readonly errors: readonly ApiErrorItem[];
+    constructor(errors: readonly ApiErrorItem[]);
+}
+/** Thrown when the HTTP request fails or answers with a non-2xx status. */
+declare class NamecheapHttpError extends Error {
+    readonly status: number | undefined;
+    readonly statusText: string;
+    constructor(message: string, init?: {
+        status?: number;
+        statusText?: string;
+        cause?: unknown;
+    });
+}
+/** Thrown when a response body cannot be parsed or has an unexpected shape. */
+declare class NamecheapParseError extends Error {
+    constructor(message: string, init?: {
+        cause?: unknown;
+    });
 }
 
 interface Paging {
     totalItems: number;
     currentPage: number;
     pageSize: number;
-    paging: boolean;
 }
 
-interface DomainGetListResult {
+type DomainsListType = "ALL" | "EXPIRING" | "EXPIRED";
+type DomainsSortBy = "NAME" | "NAME_DESC" | "EXPIREDATE" | "EXPIREDATE_DESC" | "CREATEDATE" | "CREATEDATE_DESC";
+interface DomainsGetListParams {
+    listType?: DomainsListType;
+    /** Keyword to look for in the domain list. */
+    searchTerm?: string;
+    page?: number;
+    /** Min 10, max 100. */
+    pageSize?: number;
+    sortBy?: DomainsSortBy;
+}
+interface DomainsListItem {
     id: number;
     name: string;
     user: string;
@@ -31,943 +225,896 @@ interface DomainGetListResult {
     autoRenew: boolean;
     whoisGuard: string;
     isPremium: boolean;
-    isOurDns: boolean;
+    isOurDNS: boolean;
 }
-interface Contacts {
-    registrant: ContactDetail;
-    tech: ContactDetail;
-    admin: ContactDetail;
-    auxBilling: ContactDetail;
+interface DomainsGetListResult {
+    domains: DomainsListItem[];
+    paging: Paging;
 }
-interface ContactDetail {
-    organizationName?: string;
-    jobTitle?: string;
+declare const getList$5: Command<DomainsGetListParams, DomainsGetListResult>;
+interface DomainsCheckParams {
+    /** Comma-separated list of domains to check (max 50). */
+    domainList: string;
+}
+interface DomainsCheckItem {
+    domain: string;
+    available: boolean;
+    /** Present in recorded responses, not in the reference. */
+    errorNo?: number;
+    /** Present in recorded responses, not in the reference. */
+    description?: string;
+    isPremiumName: boolean;
+    premiumRegistrationPrice: number;
+    premiumRenewalPrice: number;
+    premiumRestorePrice: number;
+    premiumTransferPrice: number;
+    icannFee: number;
+    eapFee: number;
+}
+type DomainsCheckResult = DomainsCheckItem[];
+declare const check: Command<DomainsCheckParams, DomainsCheckResult>;
+interface DomainsGetRegistrarLockParams {
+    domainName: string;
+}
+interface DomainsGetRegistrarLockResult {
+    domain: string;
+    registrarLockStatus: boolean;
+}
+declare const getRegistrarLock: Command<DomainsGetRegistrarLockParams, DomainsGetRegistrarLockResult>;
+type DomainsLockAction = "LOCK" | "UNLOCK";
+interface DomainsSetRegistrarLockParams {
+    domainName: string;
+    /** Default: LOCK. */
+    lockAction?: DomainsLockAction;
+}
+interface DomainsSetRegistrarLockResult {
+    domain: string;
+    isSuccess: boolean;
+}
+declare const setRegistrarLock: Command<DomainsSetRegistrarLockParams, DomainsSetRegistrarLockResult>;
+/**
+ * @remarks Billed: this command charges your Namecheap account.
+ */
+interface DomainsReactivateParams {
+    domainName: string;
+    promotionCode?: string;
+    /** Number of years to add after expiry. */
+    yearsToAdd?: number;
+    isPremiumDomain?: boolean;
+    /** Reactivation price for a premium domain. */
+    premiumPrice?: number | string;
+}
+interface DomainsReactivateResult {
+    domain: string;
+    isSuccess: boolean;
+    chargedAmount: number;
+    orderID: number;
+    transactionID: number;
+}
+declare const reactivate: Command<DomainsReactivateParams, DomainsReactivateResult>;
+/**
+ * @remarks Billed: this command charges your Namecheap account.
+ */
+interface DomainsRenewParams {
+    domainName: string;
+    years: number;
+    promotionCode?: string;
+    isPremiumDomain?: boolean;
+    /** Renewal price for a premium domain. */
+    premiumPrice?: number | string;
+}
+interface DomainsRenewResult {
+    domainName: string;
+    domainID: number;
+    renew: boolean;
+    chargedAmount: number;
+    orderID: number;
+    transactionID: number;
+    domainDetails: {
+        /** Date and time as sent by the server, e.g. `12/14/2034 1:01:07 PM`. */
+        expiredDate: string;
+        numYears: number;
+    };
+}
+declare const renew$2: Command<DomainsRenewParams, DomainsRenewResult>;
+/**
+ * One contact block of a request. Nested under `registrant`, `tech`, `admin` or
+ * `auxBilling`, so `registrant.firstName` is sent as `RegistrantFirstName`.
+ */
+interface DomainsContactParams {
     firstName: string;
     lastName: string;
     address1: string;
-    address2?: string;
     city: string;
     stateProvince: string;
-    stateProvinceChoice?: string;
-    postalCode: string | number;
+    postalCode: string;
     country: string;
-    phone: string | number;
-    fax?: number;
+    /** Format +NNN.NNNNNNNNNN. */
+    phone: string;
     emailAddress: string;
-    phoneExt?: number;
-    readOnly?: boolean;
+    organizationName?: string;
+    jobTitle?: string;
+    address2?: string;
 }
-interface CurrentAttributes {
-    registrantNexus: string;
-    registrantPurpose: string;
+interface DomainsSetContactsParams {
+    domainName: string;
+    registrant: DomainsContactParams;
+    tech: DomainsContactParams;
+    admin: DomainsContactParams;
+    auxBilling: DomainsContactParams;
 }
-interface DomainContactsResult extends Contacts {
-    currentAttributes: CurrentAttributes;
-    whoisGuardContact: Contacts & {
-        whoisGuardContact: boolean;
-    };
+interface DomainsSetContactsResult {
     domain: string;
-    domainnameid: number;
+    isSuccess: boolean;
+}
+declare const setContacts: Command<DomainsSetContactsParams, DomainsSetContactsResult>;
+/**
+ * @remarks Billed: this command charges your Namecheap account.
+ */
+interface DomainsCreateParams {
+    domainName: string;
+    years: number;
+    promotionCode?: string;
+    registrant: DomainsContactParams;
+    tech: DomainsContactParams;
+    admin: DomainsContactParams;
+    auxBilling: DomainsContactParams;
+    /** Comma-separated custom nameservers. */
+    nameservers?: string;
+    /** Add free domain privacy, `Yes` or `No`. Default: Yes. */
+    addFreeWhoisguard?: string;
+    /** Enable domain privacy, `Yes` or `No`. Default: No. */
+    wgEnabled?: string;
+    isPremiumDomain?: boolean;
+    /** Registration price for a premium domain. */
+    premiumPrice?: number | string;
+    /** Purchase fee for a premium domain during EAP. */
+    eapFee?: number | string;
 }
-interface DomainCreateResult {
+interface DomainsCreateResult {
     domain: string;
     registered: boolean;
     chargedAmount: number;
-    domainId: number;
-    orderId: number;
-    transactionId: number;
-    whoisguardEnable: boolean;
-    nonRealTimeDomain: boolean;
-}
-interface Category {
-    name: string;
-    sequenceNumber: number;
-}
-interface TLD {
-    value: string;
+    domainID: number;
+    orderID: number;
+    transactionID: number;
+    /** Present in recorded responses, not in the reference's response table. */
+    whoisguardEnable?: boolean;
+    /** Present in recorded responses, not in the reference's response table. */
+    nonRealTimeDomain?: boolean;
+}
+declare const create$5: Command<DomainsCreateParams, DomainsCreateResult>;
+interface DomainsTld {
     name: string;
-    nonRealTime: boolean;
+    nonRealTimeDomain: boolean;
     minRegisterYears: number;
     maxRegisterYears: number;
     minRenewYears: number;
     maxRenewYears: number;
-    renewalMinDays?: number;
-    renewalMaxDays?: number;
-    reactivateMaxDays?: number;
     minTransferYears: number;
     maxTransferYears: number;
     isApiRegisterable: boolean;
     isApiRenewable: boolean;
     isApiTransferable: boolean;
     isEppRequired: boolean;
-    isDisableModContact: boolean;
-    isDisableWgAllot: boolean;
-    isIncludeInExtendedSearchOnly: boolean;
-    sequenceNumber: number;
-    type: string;
-    subType?: string;
-    isSupportsIdn: boolean;
-    category: string;
-    supportsRegistrarLock?: boolean;
-    addGracePeriodDays?: number;
-    whoisVerification?: boolean;
-    providerApiDelete?: boolean;
-    tldState?: string;
-    searchGroup?: string;
-    registry?: string;
-    categories?: Array<Category>;
-}
-interface DomainCheckResult {
-    domain: string;
-    available: boolean;
-    errorNo: number;
-    isPremiumName: boolean;
-    premiumRegistrationPrice: number;
-    premiumRenewalPrice: number;
-    premiumRestorePrice: number;
-    premiumTransferPrice: number;
-    icannFee: number;
-    eapFee: number;
-}
-interface DomainReactivateResult {
-    domain: string;
-    isSuccess: boolean;
-    chargedAmount: number;
-    orderId: number;
-    transactionId: number;
+    /** Text content of the `Tld` element, e.g. `.com domain`. */
+    description: string;
 }
-interface DomainRenewResult {
-    domainDetails: {
-        expiredDate: string;
-        numYears: number;
-        domainDetails: boolean;
-    };
+type DomainsGetTldListResult = DomainsTld[];
+declare const getTldList: Command<Record<string, never>, DomainsGetTldListResult>;
+interface DomainsGetContactsParams {
     domainName: string;
-    domainId: number;
-    renew: true;
-    orderId: number;
-    transactionId: number;
-    chargedAmount: number;
 }
-interface DomainGetRegistrarLockResult {
+/** A contact as returned by getContacts; the API omits fields it has no value for. */
+interface DomainsContact {
+    organizationName?: string;
+    jobTitle?: string;
+    firstName?: string;
+    lastName?: string;
+    address1?: string;
+    address2?: string;
+    city?: string;
+    stateProvince?: string;
+    postalCode?: string;
+    country?: string;
+    phone?: string;
+    emailAddress?: string;
+}
+interface DomainsGetContactsResult {
     domain: string;
-    registrarLockStatus: boolean;
-    isClientUpdateProhibited?: boolean;
-    isClientDeleteProhibited?: boolean;
-    isClientHold?: boolean;
+    /** Sent as the lower-case attribute `domainnameid`. */
+    domainnameid: number;
+    readonly: boolean;
+    registrant?: DomainsContact;
+    tech?: DomainsContact;
+    admin?: DomainsContact;
+    auxBilling?: DomainsContact;
+}
+declare const getContacts: Command<DomainsGetContactsParams, DomainsGetContactsResult>;
+interface DomainsGetInfoParams {
+    domainName: string;
+    /** Hosted domain name for which domain info is requested. */
+    hostName?: string;
 }
-interface DomainGetInfoResult {
+interface DomainsGetInfoResult {
+    /** Documented as OK, Locked or Expired; absent from the recorded response. */
+    status?: string;
+    id: number;
+    domainName: string;
+    ownerName: string;
+    isOwner: boolean;
+    isPremium: boolean;
     domainDetails: {
-        createdDate: string;
-        expiredDate: string;
-        numYears?: number;
-        domainDetails: boolean;
+        /** `MM/DD/YYYY`. */
+        createdDate?: string;
+        /** `MM/DD/YYYY`. */
+        expiredDate?: string;
+        numYears: number;
     };
     whoisguard: {
-        id: number;
-        expiredDate: string;
+        /** `True`, `False` or `NotAlloted`. */
         enabled: string;
+        /** 0 means not alloted. */
+        id: number;
+        expiredDate?: string;
+        emailDetails?: {
+            whoisGuardEmail: string;
+            forwardedTo: string;
+            lastAutoEmailChangeDate: string;
+            autoEmailChangeFrequencyDays: number;
+        };
     };
-    premiumDnsSubscription?: {
+    premiumDnsSubscription: {
         useAutoRenew: boolean;
+        /** -1 means no subscription. */
         subscriptionId: number;
+        /** ISO without zone; `0001-01-01T00:00:00` means never. */
         createdDate: string;
         expirationDate: string;
         isActive: boolean;
-        premiumDnsSubscription: boolean;
     };
     dnsDetails: {
-        nameserver?: Array<string>;
         providerType: string;
-        isUsingOurDns?: boolean;
-        hostCount?: number;
-        emailType?: string;
-        dynamicDnsStatus?: boolean;
-        isFailover?: boolean;
+        isUsingOurDNS: boolean;
+        hostCount: number;
+        emailType: string;
+        dynamicDNSStatus: boolean;
+        isFailover: boolean;
+        nameservers: string[];
     };
     modificationrights: {
-        all: boolean;
+        all?: boolean;
+        rights: Array<{
+            type: string;
+            value: string;
+        }>;
     };
-    status: string;
-    id: number;
-    domainName: string;
-    ownerName: string;
-    isOwner: boolean;
-    isPremium: boolean;
 }
-
-declare const RecordType: {
-    readonly A: "A";
-    readonly AAAA: "AAAA";
-    readonly ALIAS: "ALIAS";
-    readonly CAA: "CAA";
-    readonly CNAME: "CNAME";
-    readonly MX: "MX";
-    readonly MXE: "MXE";
-    readonly NS: "NS";
-    readonly TXT: "TXT";
-    readonly URL: "URL";
-    readonly URL301: "URL301";
-    readonly FRAME: "FRAME";
-};
-type RecordType = (typeof RecordType)[keyof typeof RecordType];
-declare const EmailType: {
-    readonly MXE: "MXE";
-    readonly MX: "MX";
-    readonly FWD: "FWD";
-    readonly OX: "OX";
-};
-type EmailType = (typeof EmailType)[keyof typeof EmailType];
-declare const LockAction: {
-    readonly Lock: "LOCK";
-    readonly Unlock: "UNLOCK";
-};
-type LockAction = (typeof LockAction)[keyof typeof LockAction];
-declare const DomainListType: {
-    readonly All: "ALL";
-    readonly Expiring: "EXPIRING";
-    readonly Expired: "EXPIRED";
-};
-type DomainListType = (typeof DomainListType)[keyof typeof DomainListType];
-declare const DomainListSortBy: {
-    readonly NameAsc: "NAME";
-    readonly NameDesc: "NAME_DESC";
-    readonly ExpireDateAsc: "EXPIREDATE";
-    readonly ExpireDateDesc: "EXPIREDATE_DESC";
-    readonly CreateDateAsc: "CREATEDATE";
-    readonly CreateDateDesc: "CREATEDATE_DESC";
-};
-type DomainListSortBy = (typeof DomainListSortBy)[keyof typeof DomainListSortBy];
-declare const IdnCode: {
-    readonly AFR: "afr";
-    readonly ALB: "alb";
-    readonly ARA: "ara";
-    readonly ARG: "arg";
-    readonly ARM: "arm";
-    readonly ASM: "asm";
-    readonly AST: "ast";
-    readonly AVE: "ave";
-    readonly AWA: "awa";
-    readonly AZE: "aze";
-    readonly BAK: "bak";
-    readonly BAL: "bal";
-    readonly BAN: "ban";
-    readonly BAQ: "baq";
-    readonly BAS: "bas";
-    readonly BEL: "bel";
-    readonly BEN: "ben";
-    readonly BHO: "bho";
-    readonly BOS: "bos";
-    readonly BUL: "bul";
-    readonly BUR: "bur";
-    readonly CAR: "car";
-    readonly CAT: "cat";
-    readonly CHE: "che";
-    readonly CHI: "chi";
-    readonly CHV: "chv";
-    readonly COP: "cop";
-    readonly COS: "cos";
-    readonly CZE: "cze";
-    readonly DAN: "dan";
-    readonly DIV: "div";
-    readonly DOI: "doi";
-    readonly DUT: "dut";
-    readonly ENG: "eng";
-    readonly EST: "est";
-    readonly FAO: "fao";
-    readonly FIJ: "fij";
-    readonly FIN: "fin";
-    readonly FRE: "fre";
-    readonly FRY: "fry";
-    readonly GEO: "geo";
-    readonly GER: "ger";
-    readonly GLA: "gla";
-    readonly GLE: "gle";
-    readonly GON: "gon";
-    readonly GRE: "gre";
-    readonly GUJ: "guj";
-    readonly HEB: "heb";
-    readonly HIN: "hin";
-    readonly HUN: "hun";
-    readonly INC: "inc";
-    readonly IND: "ind";
-    readonly INH: "inh";
-    readonly ISL: "isl";
-    readonly ITA: "ita";
-    readonly JAV: "jav";
-    readonly JPN: "jpn";
-    readonly KAS: "kas";
-    readonly KAZ: "kaz";
-    readonly KHM: "khm";
-    readonly KIR: "kir";
-    readonly KOR: "kor";
-    readonly KUR: "kur";
-    readonly LAO: "lao";
-    readonly LAV: "lav";
-    readonly LIT: "lit";
-    readonly LTZ: "ltz";
-    readonly MAL: "mal";
-    readonly MKD: "mkd";
-    readonly MLT: "mlt";
-    readonly MOL: "mol";
-    readonly MON: "mon";
-    readonly MRI: "mri";
-    readonly MSA: "msa";
-    readonly NEP: "nep";
-    readonly NOR: "nor";
-    readonly ORI: "ori";
-    readonly OSS: "oss";
-    readonly PAN: "pan";
-    readonly PER: "per";
-    readonly POL: "pol";
-    readonly POR: "por";
-    readonly PUS: "pus";
-    readonly RAJ: "raj";
-    readonly RUM: "rum";
-    readonly RUS: "rus";
-    readonly SAN: "san";
-    readonly SCR: "scr";
-    readonly SIN: "sin";
-    readonly SLO: "slo";
-    readonly SLV: "slv";
-    readonly SMO: "smo";
-    readonly SND: "snd";
-    readonly SOM: "som";
-    readonly SPA: "spa";
-    readonly SRD: "srd";
-    readonly SRP: "srp";
-    readonly SWA: "swa";
-    readonly SWE: "swe";
-    readonly SYR: "syr";
-    readonly TAM: "tam";
-    readonly TEL: "tel";
-    readonly TGK: "tgk";
-    readonly THA: "tha";
-    readonly TIB: "tib";
-    readonly TUR: "tur";
-    readonly UKR: "ukr";
-    readonly URD: "urd";
-    readonly UZB: "uzb";
-    readonly VIE: "vie";
-    readonly WEL: "wel";
-    readonly YID: "yid";
-};
-type IdnCode = (typeof IdnCode)[keyof typeof IdnCode];
-declare const DomainTransferListType: {
-    readonly All: "ALL";
-    readonly InProgress: "INPROGRESS";
-    readonly Cancelled: "CANCELLED";
-    readonly Completed: "COMPLETED";
+declare const getInfo$3: Command<DomainsGetInfoParams, DomainsGetInfoResult>;
+/**
+ * The command table behind `client.domains`. Advanced use only: it is exported for custom
+ * integrations and is not covered by semver stability.
+ */
+declare const domainsCommands: {
+    getList: Command<DomainsGetListParams, DomainsGetListResult>;
+    check: Command<DomainsCheckParams, DomainsCheckResult>;
+    getRegistrarLock: Command<DomainsGetRegistrarLockParams, DomainsGetRegistrarLockResult>;
+    setRegistrarLock: Command<DomainsSetRegistrarLockParams, DomainsSetRegistrarLockResult>;
+    reactivate: Command<DomainsReactivateParams, DomainsReactivateResult>;
+    renew: Command<DomainsRenewParams, DomainsRenewResult>;
+    setContacts: Command<DomainsSetContactsParams, DomainsSetContactsResult>;
+    create: Command<DomainsCreateParams, DomainsCreateResult>;
+    getTldList: Command<Record<string, never>, DomainsGetTldListResult>;
+    getContacts: Command<DomainsGetContactsParams, DomainsGetContactsResult>;
+    getInfo: Command<DomainsGetInfoParams, DomainsGetInfoResult>;
 };
-type DomainTransferListType = (typeof DomainTransferListType)[keyof typeof DomainTransferListType];
-declare const DomainTransferSortBy: {
-    readonly DomainName: "DOMAINNAME";
-    readonly DomainNameDesc: "DOMAINNAME_DESC";
-    readonly TransferDate: "TRANSFERDATE";
-    readonly TransferDateDesc: "TRANSFERDATE_DESC";
-    readonly StatusDate: "STATUSDATE";
-    readonly StatusDateDesc: "STATUSDATE_DESC";
-};
-type DomainTransferSortBy = (typeof DomainTransferSortBy)[keyof typeof DomainTransferSortBy];
-declare const SSLType: {
-    readonly PositiveSSL: "PositiveSSL";
-    readonly EssentialSSL: "EssentialSSL";
-    readonly InstantSSL: "InstantSSL";
-    readonly InstantSSLPro: "InstantSSL Pro";
-    readonly PremiumSSL: "PremiumSSL";
-    readonly EVSSL: "EV SSL";
-    readonly PositiveSSLWildcard: "PositiveSSL Wildcard";
-    readonly EssentialSSLWildcard: "EssentialSSL Wildcard";
-    readonly PremiumSSLWildcard: "PremiumSSL Wildcard";
-    readonly PositiveSSLMultiDomain: "PositiveSSL Multi Domain";
-    readonly MultiDomainSSL: "Multi Domain SSL";
-    readonly UnifiedCommunications: "Unified Communications";
-    readonly EVMultiDomainSSL: "EV Multi Domain SSL";
-};
-type SSLType = (typeof SSLType)[keyof typeof SSLType];
-declare const SSLListType: {
-    readonly ALL: "ALL";
-    readonly Processing: "Processing";
-    readonly EmailSent: "EmailSent";
-    readonly TechnicalProblem: "TechnicalProblem";
-    readonly InProgress: "InProgress";
-    readonly Completed: "Completed";
-    readonly Deactivated: "Deactivated";
-    readonly Active: "Active";
-    readonly Cancelled: "Cancelled";
-    readonly NewPurchase: "NewPurchase";
-    readonly NewRenewal: "NewRenewal";
-};
-type SSLListType = (typeof SSLListType)[keyof typeof SSLListType];
-declare const SSLListSortBy: {
-    readonly PurchaseDate: "PURCHASEDATE";
-    readonly PurchaseDateDesc: "PURCHASEDATE_DESC";
-    readonly SSLType: "SSLTYPE";
-    readonly SSLTypeDesc: "SSLTYPE_DESC";
-    readonly ExpireDateTime: "EXPIREDATETIME";
-    readonly ExpireDateTimeDesc: "EXPIREDATETIME_DESC";
-    readonly Hostname: "Host_Name";
-    readonly HostnameDesc: "Host_Name_DESC";
-};
-type SSLListSortBy = (typeof SSLListSortBy)[keyof typeof SSLListSortBy];
-declare const UserProductType: {
-    readonly Domain: "DOMAIN";
-    readonly SslCertificate: "SSLCERTIFICATE";
-};
-type UserProductType = (typeof UserProductType)[keyof typeof UserProductType];
-declare const UserProductCategory: {
-    readonly Domains: "DOMAINS";
-    readonly Comodo: "COMODO";
-};
-type UserProductCategory = (typeof UserProductCategory)[keyof typeof UserProductCategory];
-declare const UserActionName: {
-    readonly Register: "REGISTER";
-    readonly Renew: "RENEW";
-    readonly Reactivate: "REACTIVATE";
-    readonly Transfer: "TRANSFER";
-    readonly Purchase: "PURCHASE";
-};
-type UserActionName = (typeof UserActionName)[keyof typeof UserActionName];
-declare const UserProductName: {
-    readonly COM: "COM";
-    readonly InstantSsl: "INSTANTSSL";
-};
-type UserProductName = (typeof UserProductName)[keyof typeof UserProductName];
-declare const UserPaymentType: {
-    readonly CreditCard: "Creditcard";
-};
-type UserPaymentType = (typeof UserPaymentType)[keyof typeof UserPaymentType];
-declare const UserListFindBy: {
-    readonly EmailAddress: "EMAILADDRESS";
-    readonly DomainName: "DOMAINNAME";
-    readonly Username: "USERNAME";
-};
-type UserListFindBy = (typeof UserListFindBy)[keyof typeof UserListFindBy];
-declare const WhoIsListType: {
-    readonly All: "ALL";
-    readonly Alloted: "ALLOTED";
-    readonly Free: "FREE";
-    readonly Discard: "DISCARD";
-};
-type WhoIsListType = (typeof WhoIsListType)[keyof typeof WhoIsListType];
-declare const GetAddFundsStatus: {
-    readonly Created: "CREATED";
-    readonly Submitted: "SUBMITTED";
-    readonly Completed: "COMPLETED";
-    readonly Failed: "FAILED";
-    readonly Expired: "EXPIRED";
-};
-type GetAddFundsStatus = (typeof GetAddFundsStatus)[keyof typeof GetAddFundsStatus];
-declare const DomainDnsTag: {
-    Issue: string;
-    IssueWild: string;
-    IODEF: string;
-};
-type DomainDnsTag = (typeof DomainDnsTag)[keyof typeof DomainDnsTag];
 
-interface GetListParams$1 {
-    listType?: DomainListType;
-    searchTerm?: string;
-    page?: number;
-    pageSize?: number;
-    sortBy?: DomainListSortBy;
-}
-interface CreateDomainParams extends Contacts {
-    domainName: string;
-    years: number;
-    promoCode?: string;
-    billing?: Partial<ContactDetail>;
-    idnCode?: IdnCode;
-    extendedAttributes?: string;
-    nameservers?: string;
-    addFreeWhoisguard?: string;
-    WGEnabled?: string;
-    isPremiumDomain?: boolean;
-    premiumPrice?: number;
-    eapFee?: number;
+interface DnsSetDefaultParams {
+    /** SLD of the domain name. */
+    sld: string;
+    /** TLD of the domain name. */
+    tld: string;
 }
-interface ContactDomainParams extends Contacts {
-    domainName: string;
-    extendedAttributes?: string;
+interface DnsSetDefaultResult {
+    domain: string;
+    updated: boolean;
 }
-interface ReactivateDomainParams {
-    domainName: string;
-    promotionCode?: string;
-    yearsToAdd?: number;
-    isPremiumDomain?: boolean;
-    premiumPrice?: number;
+declare const setDefault$1: Command<DnsSetDefaultParams, DnsSetDefaultResult>;
+interface DnsSetCustomParams {
+    sld: string;
+    tld: string;
+    /** Comma-separated list of nameservers. */
+    nameservers: string;
 }
-interface RenewDomainParams {
-    domainName: string;
-    years: number;
-    promotionCode?: string;
-    isPremiumDomain?: boolean;
-    premiumPrice?: number;
+interface DnsSetCustomResult {
+    domain: string;
+    updated: boolean;
 }
-
-declare class Domains {
-    private readonly config;
-    constructor(config: NamecheapProps);
-    /**
-     * Returns a list of domains for the particular user
-     * @note IMPORTANT: Namecheap API privacy service provider recently changed to WithheldforPrivacy. We want to avoid service interruption for namecheap API users, so please note that in some cases, you may still see Whoisguard in the API parameter names.
-     */
-    getList(params?: GetListParams$1): Promise<{
-        data: Array<DomainGetListResult>;
-        paging: Paging;
-    }>;
-    /**
-     * Gets contact information for the requested domain
-     * @note IMPORTANT: Namecheap API privacy service provider recently changed to WithheldforPrivacy. We want to avoid service interruption for our API users, so please note that in some cases, you may still see Whoisguard in the API parameter names.
-     */
-    getContacts(domainName: string): Promise<DomainContactsResult>;
-    /**
-     * Registers a new domain
-     * @note IMPORTANT: Namecheap API privacy service provider recently changed to WithheldforPrivacy. We want to avoid service interruption for our API users, so please note that in some cases, you may still see Whoisguard in the API parameter names.
-     * @note For successful registration of an IDN domain, you need to send the IdnCode parameter and provide the domain name in the Punycode format (Example: xn--sdkhjsdhfkdh.com), as we do not support native code.
-     */
-    create(domain: string, params: Omit<CreateDomainParams, "domainName">): Promise<DomainCreateResult>;
-    /**
-     * Returns a list of TLDs
-     * @note IMPORTANT: Namecheap API privacy service provider recently changed to WithheldforPrivacy. We want to avoid service interruption for our API users, so please note that in some cases, you may still see Whoisguard in the API parameter names.
-     * @note We strongly recommend that you cache this API response to avoid repeated calls.
-     *
-     */
-    getTldList(): Promise<Array<TLD>>;
-    /**
-     * Sets contact information for the requested domain
-     */
-    setContacts(domain: string, params: Omit<ContactDomainParams, "domainName">): Promise<string>;
-    /**
-     * Checks the availability of domains
-     */
-    check(domains: Array<string>): Promise<Array<DomainCheckResult>>;
-    /**
-     * Reactivates an expired domain
-     */
-    reactivate(domain: string, params?: Omit<ReactivateDomainParams, "domainName">): Promise<DomainReactivateResult>;
-    /**
-     * Renews an expiring domain
-     */
-    renew(domain: string, params: Omit<RenewDomainParams, "domainName">): Promise<DomainRenewResult>;
-    /**
-     * Gets the Registrar Lock status for the requested domain
-     */
-    getRegistrarLock(domain: string): Promise<DomainGetRegistrarLockResult>;
-    /**
-     * Sets the Registrar Lock status for a domain
-     */
-    setRegistrarLock(domain: string, lockAction?: LockAction): Promise<string>;
-    /**
-     * Returns information about the requested domain
-     * @note IMPORTANT: Namecheap API privacy service provider recently changed to WithheldforPrivacy. We want to avoid service interruption for Namecheap API users, so please note that in some cases, you may still see Whoisguard in the API parameter names.
-     */
-    getInfo(domain: string, hostName?: string): Promise<DomainGetInfoResult>;
+declare const setCustom: Command<DnsSetCustomParams, DnsSetCustomResult>;
+interface DnsGetListParams {
+    sld: string;
+    tld: string;
 }
-
-interface DomainDnsGetListResult {
-    nameserver: Array<string>;
+interface DnsGetListResult {
     domain: string;
-    isUsingOurDns: boolean;
+    isUsingOurDNS: boolean;
+    /** Present in recorded responses, not in the reference. */
+    isPremiumDNS?: boolean;
+    /** Present in recorded responses, not in the reference. */
+    isUsingFreeDNS?: boolean;
+    /** Taken from the recorded responses (not in the reference's response table); empty when none are listed. */
+    nameservers: string[];
+}
+declare const getList$4: Command<DnsGetListParams, DnsGetListResult>;
+interface DnsGetHostsParams {
+    sld: string;
+    tld: string;
 }
-interface Host$1 {
+interface DnsHost {
+    /** The reference spells the attribute `HostID`; responses carry `HostId`. */
     hostId: number;
     name: string;
     type: string;
     address: string;
     mxPref: number;
     ttl: number;
-}
-interface DomainDnsGetHostsResult {
-    host: Array<Host$1>;
+    /** Present in recorded responses, not in the reference. */
+    associatedAppTitle?: string;
+    /** Present in recorded responses, not in the reference. */
+    friendlyName?: string;
+    /** Present in recorded responses, not in the reference. */
+    isActive?: boolean;
+    /** Present in recorded responses, not in the reference. */
+    isDDNSEnabled?: boolean;
+}
+interface DnsGetHostsResult {
     domain: string;
-    isUsingOurDns: boolean;
+    /** Present in recorded responses, not in the reference. */
+    emailType?: string;
+    isUsingOurDNS: boolean;
+    hosts: DnsHost[];
+}
+declare const getHosts: Command<DnsGetHostsParams, DnsGetHostsResult>;
+interface DnsGetEmailForwardingParams {
+    /** Domain name to get settings for. */
+    domainName: string;
 }
-interface Forward {
-    value: string;
+interface DnsEmailForward {
     mailbox: string;
+    /** Present in recorded responses, not in the reference. */
+    forwardTo?: string;
 }
-interface DomainDnsGetEmailForwardingResult {
-    forward: Array<Forward>;
+interface DnsGetEmailForwardingResult {
     domain: string;
+    forwards: DnsEmailForward[];
 }
-
-interface SetDNSEmailForwardingParams {
+declare const getEmailForwarding: Command<DnsGetEmailForwardingParams, DnsGetEmailForwardingResult>;
+/** One forwarding rule, sent as `MailBox<n>` and `ForwardTo<n>`. */
+interface DnsEmailForwardRecord {
+    /** Mailbox for email forwarding (e.g. `example@domain.com`). */
+    mailBox: string;
+    /** Email address to forward to (e.g. `example@gmail.com`). */
+    forwardTo: string;
+}
+interface DnsSetEmailForwardingParams {
     domainName: string;
-    mailBox: Array<string>;
-    forwardTo: Array<string>;
+    /** An empty list is allowed and clears the domain's email forwarding. */
+    forwards: DnsEmailForwardRecord[];
 }
-interface Host {
-    hostname: string;
-    recordType: RecordType;
+interface DnsSetEmailForwardingResult {
+    domain: string;
+    isSuccess: boolean;
+}
+declare const setEmailForwarding: Command<DnsSetEmailForwardingParams, DnsSetEmailForwardingResult>;
+type DnsRecordType = "A" | "AAAA" | "ALIAS" | "CAA" | "CNAME" | "MX" | "MXE" | "NS" | "TXT" | "URL" | "URL301" | "FRAME";
+type DnsEmailType = "NONE" | "MXE" | "MX" | "FWD" | "OX" | "GMAIL";
+/** One host record, sent as `HostName<n>`, `RecordType<n>`, `Address<n>`, `MXPref<n>`, `TTL<n>`. */
+interface DnsHostRecord {
+    /** Sub-domain/hostname for the record. */
+    hostName: string;
+    recordType: DnsRecordType;
+    /** URL or IP address, depending on the record type. */
     address: string;
-    mxpref?: string;
+    /** MX preference (MX records only). Required by the reference, but optional on the wire. */
+    mxPref?: number;
+    /** Time to live (300-60000). */
     ttl?: number;
 }
-interface SetDNSHostsParams {
+interface DnsSetHostsParams {
     sld: string;
     tld: string;
-    emailType?: EmailType;
-    flag?: number;
-    tag?: DomainDnsTag;
-    hostname: Array<string>;
-    ttl: Array<number>;
-    address: Array<string>;
-    mxpref: Array<string>;
-    recordType: Array<RecordType>;
-}
-
-declare class DomainsDNS {
-    private readonly config;
-    constructor(config: NamecheapProps);
-    /**
-     * Sets domain to use namecheap api default DNS servers.
-     * Required for free services like Host record management, URL forwarding, email forwarding, dynamic dns and other value added services.
-     */
-    setDefault(sld: string, tld: string): Promise<string>;
-    /**
-     * Sets domain to use custom DNS servers.
-     * @note Services like URL forwarding, Email forwarding, Dynamic DNS will not work for domains using custom nameservers
-     */
-    setCustom(sld: string, tld: string, nameservers: Array<string>): Promise<string>;
-    /**
-     * Gets a list of DNS servers associated with the requested domain.
-     */
-    getList(sld: string, tld: string): Promise<DomainDnsGetListResult>;
-    /**
-     * Retrieves DNS host record settings for the requested domain.
-     */
-    getHosts(sld: string, tld: string): Promise<DomainDnsGetHostsResult>;
-    /**
-     * Gets email forwarding settings for the requested domain.
-     */
-    getEmailForwarding(domain: string): Promise<DomainDnsGetEmailForwardingResult>;
     /**
-     * Sets email forwarding for a domain name.
-     */
-    setEmailForwarding(domain: string, params: Omit<SetDNSEmailForwardingParams, "domainName">): Promise<string>;
-    /**
-     * Sets DNS host records settings for the requested domain.
-     * @note If you set more than 10 hosts the request will be done by POST method otherwise by GET method.
-     * @note All host records that are not included into the API call will be deleted, so add them in addition to new host records.
+     * Omitted keeps the zone's current mode.
+     *
+     * @remarks The reference warns that MX records are silently discarded unless the
+     * resulting email mode is `MX`. `setHosts` replaces the whole zone, so a call that
+     * lists MX hosts under another mode loses the mail routing.
      */
-    setHosts(sld: string, tld: string, params: Omit<SetDNSHostsParams, "sld" | "tld" | "address" | "hostname" | "mxpref" | "recordType" | "ttl"> & {
-        hosts: Array<Host>;
-    }): Promise<Array<string>>;
+    emailType?: DnsEmailType;
+    /** Replaces the whole zone: records not listed are deleted, so at least one is required. */
+    hosts: [DnsHostRecord, ...DnsHostRecord[]];
 }
-
-interface GenericDomain {
+interface DnsSetHostsResult {
     domain: string;
+    /** Present in recorded responses, not in the reference. */
+    emailType?: string;
+    isSuccess: boolean;
+}
+declare const setHosts: Command<DnsSetHostsParams, DnsSetHostsResult>;
+/**
+ * The command table behind `client.dns`. Advanced use only: it is exported for custom
+ * integrations and is not covered by semver stability.
+ */
+declare const dnsCommands: {
+    setDefault: Command<DnsSetDefaultParams, DnsSetDefaultResult>;
+    setCustom: Command<DnsSetCustomParams, DnsSetCustomResult>;
+    getList: Command<DnsGetListParams, DnsGetListResult>;
+    getHosts: Command<DnsGetHostsParams, DnsGetHostsResult>;
+    getEmailForwarding: Command<DnsGetEmailForwardingParams, DnsGetEmailForwardingResult>;
+    setEmailForwarding: Command<DnsSetEmailForwardingParams, DnsSetEmailForwardingResult>;
+    setHosts: Command<DnsSetHostsParams, DnsSetHostsResult>;
+};
+
+interface NsCreateParams {
+    /** SLD of the domain name. */
+    sld: string;
+    /** TLD of the domain name. */
+    tld: string;
+    /** Nameserver to create. */
     nameserver: string;
+    /** Nameserver IP address. */
+    ip: string;
 }
-interface DomainNsCreateResult extends GenericDomain {
+interface NsCreateResult {
+    domain: string;
+    nameserver: string;
     ip: string;
     isSuccess: boolean;
 }
-interface DomainNsDeleteResult extends GenericDomain {
+declare const create$4: Command<NsCreateParams, NsCreateResult>;
+interface NsDeleteParams {
+    sld: string;
+    tld: string;
+    /** Nameserver to delete. */
+    nameserver: string;
+}
+interface NsDeleteResult {
+    domain: string;
+    nameserver: string;
     isSuccess: boolean;
 }
-interface DomainNsInfoResult extends GenericDomain {
-    nameserverStatuses: Array<string>;
+declare const deleteNs: Command<NsDeleteParams, NsDeleteResult>;
+interface NsGetInfoParams {
+    sld: string;
+    tld: string;
+    /** Nameserver to get info for. */
+    nameserver: string;
 }
-interface DomainNsUpdateResult {
+interface NsGetInfoResult {
     domain: string;
-    nameserverStatuses: Array<string>;
-    isSuccess: boolean;
+    nameserver: string;
+    ip: string;
+    /** Present in recorded responses, not in the reference. */
+    nameserverStatuses?: string[];
 }
-
-declare class DomainsNS {
-    private readonly config;
-    constructor(config: NamecheapProps);
-    create(sld: string, tld: string, nameserver: string, ip: string): Promise<DomainNsCreateResult>;
-    delete(sld: string, tld: string, nameserver: string): Promise<DomainNsDeleteResult>;
-    getInfo(sld: string, tld: string, nameserver: string): Promise<DomainNsInfoResult>;
-    update(sld: string, tld: string, nameserver: string, ip: string, oldIp: string): Promise<DomainNsUpdateResult>;
+declare const getInfo$2: Command<NsGetInfoParams, NsGetInfoResult>;
+interface NsUpdateParams {
+    sld: string;
+    tld: string;
+    /** Nameserver to update. */
+    nameserver: string;
+    /** Existing IP address. */
+    oldIP: string;
+    /** New IP address. */
+    ip: string;
+}
+interface NsUpdateResult {
+    domain: string;
+    nameserver: string;
+    isSuccess: boolean;
 }
+declare const update$2: Command<NsUpdateParams, NsUpdateResult>;
+/**
+ * The command table behind `client.ns`. Advanced use only: it is exported for custom
+ * integrations and is not covered by semver stability.
+ */
+declare const nsCommands: {
+    create: Command<NsCreateParams, NsCreateResult>;
+    delete: Command<NsDeleteParams, NsDeleteResult>;
+    getInfo: Command<NsGetInfoParams, NsGetInfoResult>;
+    update: Command<NsUpdateParams, NsUpdateResult>;
+};
 
-interface CreateTransferParams {
+/**
+ * @remarks Billed: this command charges your Namecheap account.
+ */
+interface TransferCreateParams {
+    /** Domain name to transfer. */
     domainName: string;
+    /** Should be set to 1 year only. */
     years: number;
+    /** EPP (authorization) code, required for most TLDs. */
     eppCode: string;
-    promotionCode: string;
-    addFreeWhoisGuard: boolean;
-    wGenable: boolean;
-}
-interface GetListTransferParams {
-    listType?: DomainTransferListType;
-    searchTerm?: string;
-    page?: number;
-    pageSize?: number;
-    sortBy?: DomainTransferSortBy;
+    promotionCode?: string;
+    /** Add free domain privacy, `Yes` or `No`. Default: Yes. */
+    addFreeWhoisguard?: string;
+    /** Enable domain privacy, `Yes` or `No`. Default: No. Sent as `WGenable`. */
+    wgEnable?: string;
 }
-
-interface DomainTransferCreateResult {
-    domainname: string;
-    transfer: boolean;
-    transferId: number;
-    statusId: number;
-    orderId: number;
-    transactionId: number;
+interface TransferCreateResult {
+    domainName: string;
+    transferID: number;
+    statusID: number;
+    orderID: number;
+    transactionID: number;
     chargedAmount: number;
-    statusCode: number;
 }
-interface DomainTransferGetStatusResult {
-    transferId: number;
+declare const create$3: Command<TransferCreateParams, TransferCreateResult>;
+interface TransferGetStatusParams {
+    transferID: number;
+}
+interface TransferGetStatusResult {
+    transferID: number;
+    statusID: number;
     status: string;
-    statusId: number;
 }
-interface TransferGetResult {
-    id: number;
-    domainname: string;
+declare const getStatus: Command<TransferGetStatusParams, TransferGetStatusResult>;
+interface TransferUpdateStatusParams {
+    transferID: number;
+    /** `true` resubmits the transfer. */
+    resubmit: boolean;
+}
+interface TransferUpdateStatusResult {
+    transferID: number;
+    resubmit: boolean;
+}
+declare const updateStatus: Command<TransferUpdateStatusParams, TransferUpdateStatusResult>;
+type TransferListType = "ALL" | "INPROGRESS" | "CANCELLED" | "COMPLETED";
+type TransferSortBy = "DOMAINNAME" | "DOMAINNAME_DESC" | "TRANSFERDATE" | "TRANSFERDATE_DESC" | "STATUSDATE" | "STATUSDATE_DESC";
+interface TransferGetListParams {
+    /** Default: ALL. */
+    listType?: TransferListType;
+    /** Keyword (domain name) to search. */
+    searchTerm?: string;
+    page?: number;
+    /** Min 10, max 100. */
+    pageSize?: number;
+    sortBy?: TransferSortBy;
+}
+interface TransferListItem {
+    transferID: number;
+    /** The reference spells this column `Domainname`; the fixture uses `DomainName`. */
+    domainName: string;
     user: string;
     transferDate: string;
-    orderId: number;
-    statusId: number;
+    orderID: number;
+    statusID: number;
     status: string;
-    statusDate: string;
-    statusDescription: string;
-}
-
-declare class DomainsTransfer {
-    private readonly config;
-    constructor(config: NamecheapProps);
-    create(domain: string, params: Omit<CreateTransferParams, "domainName">): Promise<DomainTransferCreateResult>;
-    getStatus(id: number): Promise<DomainTransferGetStatusResult>;
-    updateStatus(id: number, resubmit: boolean): Promise<number>;
-    getList(params?: GetListTransferParams): Promise<{
-        data: Array<TransferGetResult>;
-        paging: Paging;
-    }>;
 }
+interface TransferGetListResult {
+    transfers: TransferListItem[];
+    paging: Paging;
+}
+declare const getList$3: Command<TransferGetListParams, TransferGetListResult>;
+/**
+ * The command table behind `client.transfer`. Advanced use only: it is exported for custom
+ * integrations and is not covered by semver stability.
+ */
+declare const transferCommands: {
+    create: Command<TransferCreateParams, TransferCreateResult>;
+    getStatus: Command<TransferGetStatusParams, TransferGetStatusResult>;
+    updateStatus: Command<TransferUpdateStatusParams, TransferUpdateStatusResult>;
+    getList: Command<TransferGetListParams, TransferGetListResult>;
+};
 
-type CreateSSLYearLimit = 1 | 2 | 3 | 4 | 5;
-interface CreateSSLParams {
-    year: CreateSSLYearLimit;
-    type: SSLType;
-    sansToADD?: number;
+/**
+ * @remarks Billed: this command charges your Namecheap account.
+ */
+interface SslCreateParams {
+    /** Number of years for the certificate. Allowed values: 1 to 5. */
+    years: number;
+    /** SSL product name. */
+    type: string;
+    /** Number of add-on domains for multi-domain certificates. Sent as `SANStoADD`. */
+    sansToAdd?: number;
     promotionCode?: string;
 }
-interface GetListSSLParams {
-    listType?: SSLListType;
+/** Every field is optional: the response shape of this billed command is not documented. */
+interface SslCreateResult {
+    isSuccess?: boolean;
+    orderID?: number;
+    transactionID?: number;
+    chargedAmount?: number;
+    certificateID?: number;
+    created?: string;
+    sslType?: string;
+    status?: string;
+}
+declare const create$2: Command<SslCreateParams, SslCreateResult>;
+type SslListType = "ALL" | "Processing" | "EmailSent" | "TechnicalProblem" | "InProgress" | "Completed" | "Deactivated" | "Active" | "Cancelled" | "NewPurchase" | "NewRenewal";
+type SslSortBy = "PURCHASEDATE" | "PURCHASEDATE_DESC" | "SSLTYPE" | "SSLTYPE_DESC" | "EXPIREDATETIME" | "EXPIREDATETIME_DESC" | "Host_Name" | "Host_Name_DESC";
+interface SslGetListParams {
+    /** Default: ALL. */
+    listType?: SslListType;
+    /** Keyword to look for. */
     searchTerm?: string;
     page?: number;
+    /** Min 10, max 100. Default: 20. */
     pageSize?: number;
-    sortBy?: SSLListSortBy;
-}
-interface ActivateSSLCommonParams {
-    certificateId: number;
-    csr: string;
-    adminEmailAddress: string;
-    webServerType?: string;
-    uniqueValue?: string;
-}
-interface SSLDCVParams extends ActivateSSLCommonParams {
-    approverEmail?: string;
-    HTTPDCValidation?: boolean;
-    DNSDCValidation?: boolean;
-}
-interface SSLMultiDomainParams extends ActivateSSLCommonParams {
-    DNSNames?: string;
-    DNSApproverEmails?: string;
-}
-interface SSLOVAndEVParams extends ActivateSSLCommonParams {
-    adminOrganizationName?: string;
-    organizationDepartment?: string;
-    DNSNames?: string;
-    DNSApproverEmails?: string;
-    adminCountry?: string;
-    adminStateProvince?: string;
-    adminCity?: string;
-    adminAddress1?: string;
-    adminAddress2?: string;
-    adminPostalCode?: string;
-    adminPhone?: string;
-    organizationDUNS?: string;
-}
-interface SSLEVParams extends ActivateSSLCommonParams {
-    companyIncorporationCountry: string;
-    companyIncorporationStateProvince?: string;
-    companyIncorporationLocality?: string;
-    companyIncorporationDate?: string;
-    companyDBA?: string;
-    companyRegistrationNumber?: string;
-}
-interface SSLOVParams extends ActivateSSLCommonParams {
-    organizationRepFirstName?: string;
-    organizationRepLastName?: string;
-    organizationRepTitle?: string;
-    organizationRepPhone?: string;
-    organizationRepEmailAddress?: string;
-}
-type SSLParams = SSLDCVParams | SSLMultiDomainParams | SSLOVAndEVParams | SSLEVParams | SSLOVParams;
-type ActivateSSLParams = SSLParams;
-type ReissueSSLParams = SSLParams;
-interface RenewSSLParams {
-    certificateId: number;
-    years: number;
-    sslType: SSLType;
-    promotionCode?: string;
+    sortBy?: SslSortBy;
 }
-interface EditDCVMethodParams {
-    certificateId: number;
-    DCVMethod: string;
-    DNSNames: string;
-    DCVMethods: string;
-}
-
-interface SSLCertificate {
-    certificateId: number;
-    created: string;
-    sslType: string;
-    years: number;
-    status: string;
-}
-interface SSLCreateResult {
-    sslCertificate: SSLCertificate;
-    isSuccess: boolean;
-    orderId: number;
-    transactionId: number;
-    chargedAmount: number;
-}
-interface SSLResult {
-    certificateId: number;
+interface SslListItem {
+    certificateID: number;
     hostName: string;
     sslType: string;
     purchaseDate: string;
     expireDate: string;
-    activationExpireDate: string;
-    isExpiredYn: boolean;
-    status: string;
+    /** Present in the fixtures but not in the reference table. */
+    status?: string;
 }
-interface SSLParseCsrResult {
+interface SslGetListResult {
+    certificates: SslListItem[];
+    paging: Paging;
+}
+declare const getList$2: Command<SslGetListParams, SslGetListResult>;
+interface SslParseCsrParams {
+    /** Certificate Signing Request (PEM text). Sent as the lowercase `csr`. */
+    csr: string;
+    certificateType?: string;
+}
+interface SslParseCsrResult {
     commonName: string;
     domainName: string;
     country: string;
     organisationUnit: string;
     organisation: string;
-    validTrueDomain: boolean;
     state: string;
     locality: string;
     email: string;
-    dnsNames: string;
-    csrDetails: boolean;
 }
-interface GetApproverEmailListResult {
-    domainemails: string;
-    genericemails: Array<string>;
-    domain: string;
+declare const parseCSR: Command<SslParseCsrParams, SslParseCsrResult>;
+interface SslGetApproverEmailListParams {
+    domainName: string;
+    certificateType: string;
+}
+interface SslGetApproverEmailListResult {
+    /** Domain WHOIS email addresses (`Domainemails`). */
+    domainEmails: string[];
+    /** Generic email addresses for the domain (`Genericemails`). */
+    genericEmails: string[];
+    /** Additional emails from the provider (`Manualemails`). */
+    manualEmails: string[];
+}
+declare const getApproverEmailList: Command<SslGetApproverEmailListParams, SslGetApproverEmailListResult>;
+interface SslHttpDcValidation {
+    /** True when HTTP_CSR_HASH was set for at least one domain. */
+    valueAvailable: boolean;
+    fileName?: string;
+    fileContent?: string;
+}
+interface SslActivateParams {
+    certificateID: number;
+    /** Certificate Signing Request (PEM text, may span several lines). */
+    csr: string;
+    /** Email to send the signed certificate file to. */
+    adminEmailAddress: string;
+    /** Server software type, e.g. `apacheopenssl`, `nginx`, `iis`. */
+    webServerType?: string;
+    uniqueValue?: string;
 }
-interface SSLActivateResult {
-    httpDcValidation: {
-        fileName: string;
-        fileContent: string;
-        domain: string;
-    };
-    dnsdcValidation: {
-        hostName: string;
-        target: string;
-        domain: string;
-    };
+interface SslActivateResult {
     id: number;
     isSuccess: boolean;
+    /** Present when the response carries an HTTP DCV block. */
+    httpDCValidation?: SslHttpDcValidation;
 }
-interface SSLGetInfoResult {
-    certificateDetails: {
-        csr: string;
-        approverEmail: string;
-        commonName: string;
-        administratorName: string;
-        administratorEmail: string;
-        certificates: {
-            certificate: string;
-            caCertificates: Array<{
-                certificate: string;
-                type: string;
-            }>;
-            certificateReturned: boolean;
-            returnType: string;
-        };
-        certificateDetails: boolean;
-    };
-    provider: {
-        orderId: number;
-        name: string;
-        provider: boolean;
-    };
-    status: string;
-    statusDescription: string;
-    type: string;
-    issuedOn: string;
-    expires: string;
-    orderId: number;
-    replacedBy: number;
-    sansCount: number;
+declare const activate: Command<SslActivateParams, SslActivateResult>;
+interface SslResendApproverEmailParams {
+    certificateID: number;
 }
-interface SSLRenewResult {
-    certificateId: number;
-    sslType: string;
-    years: number;
-    orderId: number;
-    transactionId: number;
-    chargedAmount: number;
-}
-interface SSLPurchaseMoreSansResult {
-    sslCertificate: {
-        certificateId: number;
-        sslType: string;
-        years: number;
-        status: string;
-        sansCount: number;
-    };
-    isSuccess: boolean;
-    orderId: number;
-    transactionId: number;
-    chargedAmount: number;
-}
-interface SSLEditDcvMethodResult {
-    httpDcValidation: {
-        fileName: string;
-        fileContent: string;
-        valueAvailable: boolean;
-    };
-    dnsdcValidation: {
-        hostName: string;
-        target: string;
-        valueAvailable: boolean;
-    };
-    domains: {
-        domains: boolean;
-    };
+/** The `{ id, isSuccess }` result shared by the two resend commands. */
+interface SslResendResult {
     id: number;
     isSuccess: boolean;
 }
-
-declare class SSL {
-    private readonly config;
-    constructor(config: NamecheapProps);
-    create(params: CreateSSLParams): Promise<SSLCreateResult>;
-    getList(params: GetListSSLParams): Promise<Array<SSLResult>>;
-    parseCSR(csr: string, certificateType?: SSLType): Promise<SSLParseCsrResult>;
-    getApproverEmailList(domainName: string, certificateType?: SSLType): Promise<GetApproverEmailListResult>;
-    activate(certificateId: number, params: Omit<ActivateSSLParams, "certificateId">): Promise<SSLActivateResult>;
-    resendApproverEmail(certificateId: number): Promise<number>;
-    getInfo(certificateId: number): Promise<SSLGetInfoResult>;
-    renew(certificateId: number, params: Omit<RenewSSLParams, "certificateId">): Promise<SSLRenewResult>;
-    reissue(certificateId: number, params: Omit<ReissueSSLParams, "certificateId">): Promise<SSLActivateResult>;
-    resendFulfillmentEmail(certificateId: number): Promise<number>;
-    purchaseMoreSANS(certificateId: number, numberOfSANSToAdd: number): Promise<SSLPurchaseMoreSansResult>;
-    revokeCertificate(certificateId: number, certificateType: SSLType): Promise<number>;
-    editDCVMethod(certificateId: number, params: Omit<EditDCVMethodParams, "certificateId">): Promise<SSLEditDcvMethodResult>;
+type SslResendApproverEmailResult = SslResendResult;
+declare const resendApproverEmail: Command<SslResendApproverEmailParams, SslResendResult>;
+interface SslReissueParams {
+    certificateID: number;
+    /** Certificate Signing Request (PEM text, may span several lines). */
+    csr: string;
+    /** Cannot be changed from the initial activation. */
+    adminEmailAddress?: string;
+    webServerType?: string;
+    uniqueValue?: string;
+}
+type SslReissueResult = SslActivateResult;
+declare const reissue: Command<SslReissueParams, SslActivateResult>;
+interface SslResendFulfillmentEmailParams {
+    certificateID: number;
+}
+type SslResendFulfillmentEmailResult = SslResendResult;
+declare const resendFulfillmentEmail: Command<SslResendFulfillmentEmailParams, SslResendResult>;
+/** Either one `dcvMethod` for the whole certificate, or `dnsNames` plus `dcvMethods` per domain. */
+type SslEditDcvMethodParams = {
+    certificateID: number;
+    /** DCV method used to validate domain control. */
+    dcvMethod: string;
+} | {
+    certificateID: number;
+    /** Comma-separated list of domain names. */
+    dnsNames: string;
+    /** Comma-separated list of DCV methods, one per domain name. */
+    dcvMethods: string;
+};
+type SslEditDcvMethodResult = SslActivateResult;
+declare const editDCVMethod: Command<SslEditDcvMethodParams, SslActivateResult>;
+type SslReturnType = "Individual" | "PKCS7";
+interface SslGetInfoParams {
+    certificateID: number;
+    /**
+     * Flag for returning the certificate in the response. Sent as `Returncertificate`.
+     *
+     * @remarks The response shape for the certificate body is undocumented, so 1.0 does
+     * not parse it: the result never contains the certificate.
+     */
+    returnCertificate?: string;
+    /** Format of the returned certificate. Sent as `Returntype`. */
+    returnType?: SslReturnType;
+}
+interface SslGetInfoResult {
+    certificateID: number;
+    /** For example `Active`, `Newpurchase`, `Purchased`, `Cancelled`. */
+    status: string;
+    /** The attributes below are in the fixture but not in the reference. */
+    type?: string;
+    commonName?: string;
+    provider?: string;
+    issuedOn?: string;
+    expires?: string;
+}
+declare const getInfo$1: Command<SslGetInfoParams, SslGetInfoResult>;
+/**
+ * @remarks Billed: this command charges your Namecheap account.
+ */
+interface SslRenewParams {
+    certificateID: number;
+    /** Allowed values: 1 to 5. */
+    years: number;
+    /** SSL product name. */
+    sslType: string;
+    promotionCode?: string;
 }
+/** Every field is optional: the response shape of this billed command is not documented. */
+interface SslRenewResult {
+    certificateID?: number;
+    years?: number;
+    orderID?: number;
+    transactionID?: number;
+    chargedAmount?: number;
+}
+declare const renew$1: Command<SslRenewParams, SslRenewResult>;
+/**
+ * @remarks Billed: this command charges your Namecheap account.
+ */
+interface SslPurchaseMoreSansParams {
+    certificateID: number;
+    /** Number of add-on domains to order. Sent as `NumberOfSANSToAdd`. */
+    numberOfSansToAdd: number;
+}
+/** Every field is optional: the response shape of this billed command is not documented. */
+interface SslPurchaseMoreSansResult {
+    isSuccess?: boolean;
+    orderID?: number;
+    transactionID?: number;
+    chargedAmount?: number;
+    certificateID?: number;
+    sslType?: string;
+    /** Number of add-on domains (`SANSCount`). */
+    sansCount?: number;
+}
+declare const purchaseMoreSans: Command<SslPurchaseMoreSansParams, SslPurchaseMoreSansResult>;
+/**
+ * @remarks Irreversible: a revoked certificate cannot be restored.
+ */
+interface SslRevokeCertificateParams {
+    certificateID: number;
+    certificateType: string;
+}
+interface SslRevokeCertificateResult {
+    isSuccess: boolean;
+    certificateID: number;
+}
+declare const revokeCertificate: Command<SslRevokeCertificateParams, SslRevokeCertificateResult>;
+/**
+ * The command table behind `client.ssl`. Advanced use only: it is exported for custom
+ * integrations and is not covered by semver stability.
+ */
+declare const sslCommands: {
+    create: Command<SslCreateParams, SslCreateResult>;
+    getList: Command<SslGetListParams, SslGetListResult>;
+    parseCSR: Command<SslParseCsrParams, SslParseCsrResult>;
+    getApproverEmailList: Command<SslGetApproverEmailListParams, SslGetApproverEmailListResult>;
+    activate: Command<SslActivateParams, SslActivateResult>;
+    resendApproverEmail: Command<SslResendApproverEmailParams, SslResendResult>;
+    reissue: Command<SslReissueParams, SslActivateResult>;
+    resendFulfillmentEmail: Command<SslResendFulfillmentEmailParams, SslResendResult>;
+    editDCVMethod: Command<SslEditDcvMethodParams, SslActivateResult>;
+    getInfo: Command<SslGetInfoParams, SslGetInfoResult>;
+    renew: Command<SslRenewParams, SslRenewResult>;
+    purchaseMoreSans: Command<SslPurchaseMoreSansParams, SslPurchaseMoreSansResult>;
+    revokeCertificate: Command<SslRevokeCertificateParams, SslRevokeCertificateResult>;
+};
 
-interface GetPricingUserParams {
-    productType: UserProductType;
-    productCategory?: UserProductCategory;
+interface UsersGetBalancesResult {
+    currency: string;
+    availableBalance: string;
+    accountBalance: string;
+    earnedAmount: string;
+    withdrawableAmount: string;
+    fundsRequiredForAutoRenew: string;
+}
+declare const getBalances: Command<Record<string, never>, UsersGetBalancesResult>;
+interface UsersGetPricingParams {
+    /** Product type, e.g. `DOMAIN` or `SSLCERTIFICATE` (the reference gives examples, not a closed set). */
+    productType: string;
+    productCategory?: string;
     promotionCode?: string;
-    actionName?: UserActionName;
-    productName?: UserProductName;
+    /** Action, e.g. `REGISTER`, `RENEW` or `TRANSFER` (examples, not a closed set). */
+    actionName?: string;
+    productName?: string;
 }
-interface UpdateParams {
+interface PricingPrice {
+    duration: number;
+    durationType: string;
+    /** Final price. May be an empty string. */
+    price: string;
+    regularPrice: string;
+    yourPrice: string;
+    currency: string;
+    /** Present in the fixture but not in the reference table. */
+    pricingType?: string;
+    /** Present in the fixture but not in the reference table. */
+    regularPriceType?: string;
+    /** Present in the fixture but not in the reference table. */
+    yourPriceType?: string;
+    /** Documented; present only when a promotion applies to the tier. */
+    promotionPrice?: string;
+}
+interface PricingProduct {
+    name: string;
+    prices: PricingPrice[];
+}
+interface PricingProductCategory {
+    name: string;
+    products: PricingProduct[];
+}
+interface PricingProductType {
+    name: string;
+    productCategories: PricingProductCategory[];
+}
+interface UsersGetPricingResult {
+    productTypes: PricingProductType[];
+}
+declare const getPricing: Command<UsersGetPricingParams, UsersGetPricingResult>;
+/**
+ * Credential-bearing: changes the password of a real account. Either the old
+ * password (method 1) or a reset code from `resetPassword` (method 2).
+ */
+type UsersChangePasswordParams = {
+    oldPassword: string;
+    newPassword: string;
+} | {
+    resetCode: string;
+    newPassword: string;
+};
+/** Never echoes a password or reset code. */
+interface UsersChangePasswordResult {
+    success: boolean;
+    userID: number;
+}
+declare const changePassword: Command<UsersChangePasswordParams, UsersChangePasswordResult>;
+interface UsersUpdateParams {
     firstName: string;
     lastName: string;
     jobTitle?: string;
@@ -977,26 +1124,63 @@ interface UpdateParams {
     city: string;
     stateProvince: string;
     zip: string;
+    /** Two-letter country code. */
     country: string;
     emailAddress: string;
+    /** Format +NNN.NNNNNNNNNN. */
     phone: string;
     phoneExt?: string;
+    /** Format +NNN.NNNNNNNNNN. */
     fax?: string;
 }
-interface CreateAddFundsRequestParams {
-    username: string;
-    paymentType: typeof UserPaymentType.CreditCard;
-    amount: number;
+interface UsersUpdateResult {
+    success: boolean;
+}
+declare const update$1: Command<UsersUpdateParams, UsersUpdateResult>;
+/** The only documented payment type. */
+type UsersPaymentType = "Creditcard";
+/**
+ * The documented `Username` parameter is not exposed: the transport always sends
+ * the configured account as `UserName`.
+ *
+ * @remarks Billed: this command creates a request to add money to your Namecheap account balance.
+ */
+interface UsersCreateAddFundsRequestParams {
+    paymentType: UsersPaymentType;
+    /** Amount to add. */
+    amount: number | string;
+    /** URL to redirect the user to after payment. Sent as `ReturnUrl`. */
     returnUrl: string;
 }
-interface CreateUserParams {
+interface UsersCreateAddFundsRequestResult {
+    tokenID: string;
+    redirectURL: string;
+    returnURL: string;
+}
+declare const createAddFundsRequest: Command<UsersCreateAddFundsRequestParams, UsersCreateAddFundsRequestResult>;
+interface UsersGetAddFundsStatusParams {
+    /** Token from `createAddFundsRequest`. Sent as `TokenId` (not `TokenID`). */
+    tokenId: string;
+}
+interface UsersGetAddFundsStatusResult {
+    transactionID: number;
+    amount: string;
+    /** One of CREATED, SUBMITTED, COMPLETED, FAILED, EXPIRED. */
+    status: string;
+}
+declare const getAddFundsStatus: Command<UsersGetAddFundsStatusParams, UsersGetAddFundsStatusResult>;
+/** Credential-bearing: creates a real account under the ApiUser with its password. */
+interface UsersCreateParams {
     newUserName: string;
     newUserPassword: string;
     emailAddress: string;
+    /** Whether to skip the duplicate e-mail check. Default: Yes. */
     ignoreDuplicateEmailAddress?: string;
     firstName: string;
     lastName: string;
+    /** Must be 1 to accept the terms. */
     acceptTerms: number;
+    /** 1 to receive newsletters, 0 to opt out. */
     acceptNews?: number;
     jobTitle?: string;
     organization?: string;
@@ -1005,117 +1189,128 @@ interface CreateUserParams {
     city: string;
     stateProvince: string;
     zip: string;
+    /** Two-letter country code. */
     country: string;
+    /** Format +NNN.NNNNNNNNNN. */
     phone: string;
     phoneExt?: string;
     fax?: string;
 }
-interface ResetPasswordParams {
-    findBy: UserListFindBy;
+/**
+ * Neither the reference nor the SDK documents a response for this command, so the
+ * attributes of the first element inside `CommandResponse` are returned as-is
+ * (empty when there is none). Parsing never throws: the account may already exist.
+ */
+type UsersCreateResult = Record<string, string>;
+declare const create$1: Command<UsersCreateParams, UsersCreateResult>;
+/**
+ * Credential-bearing. Validates the password of an account created via
+ * `users.create` (the account is the configured `userName`).
+ */
+interface UsersLoginParams {
+    password: string;
+}
+/**
+ * The response shape is not documented anywhere; the documented attributes are read
+ * from the first element inside `CommandResponse`, whatever its name, and left
+ * out when absent.
+ */
+interface UsersLoginResult {
+    username?: string;
+    loginSuccess?: boolean;
+}
+declare const login: Command<UsersLoginParams, UsersLoginResult>;
+type UsersResetPasswordFindBy = "EMAILADDRESS" | "DOMAINNAME" | "USERNAME";
+/** Credential-bearing: e-mails a password reset link for a real account. */
+interface UsersResetPasswordParams {
+    findBy: UsersResetPasswordFindBy;
+    /** The username, e-mail address or domain to search by. */
     findByValue: string;
+    /** Sender name in the reset e-mail. Default: namecheap.com. */
     emailFromName?: string;
+    /** Sender address. Default: support@namecheap.com. */
     emailFrom?: string;
+    /** URL pattern containing the `[RESETCODE]` placeholder. Sent as `URLPattern`. */
     urlPattern?: string;
 }
+/** The response shape is not documented anywhere; read tolerantly from the first child of `CommandResponse`. */
+interface UsersResetPasswordResult {
+    success?: boolean;
+}
+declare const resetPassword: Command<UsersResetPasswordParams, UsersResetPasswordResult>;
+/**
+ * The command table behind `client.users`. Advanced use only: it is exported for custom
+ * integrations and is not covered by semver stability.
+ */
+declare const usersCommands: {
+    getBalances: Command<Record<string, never>, UsersGetBalancesResult>;
+    getPricing: Command<UsersGetPricingParams, UsersGetPricingResult>;
+    changePassword: Command<UsersChangePasswordParams, UsersChangePasswordResult>;
+    update: Command<UsersUpdateParams, UsersUpdateResult>;
+    createAddFundsRequest: Command<UsersCreateAddFundsRequestParams, UsersCreateAddFundsRequestResult>;
+    getAddFundsStatus: Command<UsersGetAddFundsStatusParams, UsersGetAddFundsStatusResult>;
+    create: Command<UsersCreateParams, UsersCreateResult>;
+    login: Command<UsersLoginParams, UsersLoginResult>;
+    resetPassword: Command<UsersResetPasswordParams, UsersResetPasswordResult>;
+};
 
-interface Product {
-    duration: number;
-    durationType: string;
-    price: number;
-    regularPrice: number;
-    yourPrice: number;
-    currency: string;
-}
-interface ProductCategory {
-    product: Array<Product>;
-    name: string;
-}
-interface UserGetPricingResult {
-    productCategory: Array<ProductCategory>;
-    name: string;
-}
-interface UserGetBalancesResult {
-    currency: string;
-    availableBalance: number;
-    accountBalance: number;
-    earnedAmount: number;
-    withdrawableAmount: number;
-    fundsRequiredForAutoRenew: number;
-}
-interface UserCreateAddFundsRequest {
-    tokenId: string;
-    returnUrl: string;
-    redirectUrl: string;
-}
-interface GetAddFundsStatusResult {
-    transactionId: number;
-    amount: number;
-    status: GetAddFundsStatus;
-}
-
-declare class Users {
-    private readonly config;
-    constructor(config: NamecheapProps);
-    getPricing(params: GetPricingUserParams): Promise<UserGetPricingResult>;
-    getBalances(): Promise<UserGetBalancesResult>;
-    changePassword(oldPassword: string, newPassword: string): Promise<string>;
-    update(params: UpdateParams): Promise<string>;
-    createAddFundsRequest(username: string, params: Omit<CreateAddFundsRequestParams, "username">): Promise<UserCreateAddFundsRequest>;
-    getAddFundsStatus(tokenId: string): Promise<GetAddFundsStatusResult>;
-    create(param: CreateUserParams): Promise<number>;
-    login(password: string): Promise<string>;
-    resetPassword(params: ResetPasswordParams): Promise<string>;
-}
-
-interface AddressCreateResult {
-    success: boolean;
-    addressId: number;
-    addressName: string;
-}
-interface AddressDeleteResult {
-    success: boolean;
-    profileId: number;
-    userName: string;
-}
-interface GetAddressInfoResult {
-    addressId: number;
-    userName: string;
+interface UsersAddressCreateParams {
+    /** Address name/label (max 20 characters). */
     addressName: string;
-    defaultYn: boolean;
+    /** 1 to set as the default address, 0 otherwise. */
+    defaultYN?: number;
+    emailAddress: string;
     firstName: string;
     lastName: string;
-    jobTitle: string;
-    organization: string;
+    jobTitle?: string;
+    organization?: string;
     address1: string;
-    address2: string;
+    address2?: string;
     city: string;
     stateProvince: string;
     stateProvinceChoice: string;
-    zip: number;
+    zip: string;
+    /** Two-letter country code. */
     country: string;
-    phone: number;
-    fax: number;
-    phoneExt: number;
-    emailAddress: string;
-    getAddressInfoResult: boolean;
+    /** Format +NNN.NNNNNNNNNN. */
+    phone: string;
+    phoneExt?: string;
+    /** Format +NNN.NNNNNNNNNN. */
+    fax?: string;
 }
-interface AddressGetListResult {
+interface UsersAddressCreateResult {
+    success: boolean;
     addressId: number;
     addressName: string;
 }
-interface AddressUpdateResult {
+declare const create: Command<UsersAddressCreateParams, UsersAddressCreateResult>;
+interface UsersAddressDeleteParams {
+    /** Sent as `AddressId`. */
+    addressId: number;
+}
+interface UsersAddressDeleteResult {
     success: boolean;
+    /** Id of the deleted address profile (`ProfileId`). */
+    profileId: number;
+    /** Listed in the official docs; absent from the captured response. */
+    username?: string;
+}
+declare const deleteAddress: Command<UsersAddressDeleteParams, UsersAddressDeleteResult>;
+interface UsersAddressGetInfoParams {
+    /** Sent as `AddressId`; 0 is the primary address. */
     addressId: number;
-    addressName: string;
 }
-
-interface CreateUserAddressParams {
+/** Fields the reference says are omitted (not sent empty) when they have no value are optional. */
+interface UsersAddressGetInfoResult {
+    addressId: number;
+    userName: string;
     addressName: string;
-    defaultYN?: number;
-    emailAddress: string;
+    /** From the `Default_YN` element. */
+    defaultYN: boolean;
     firstName: string;
     lastName: string;
     jobTitle?: string;
+    /** Not listed as omitted in the reference, but optional on the API side. */
     organization?: string;
     address1: string;
     address2?: string;
@@ -1127,79 +1322,141 @@ interface CreateUserAddressParams {
     phone: string;
     phoneExt?: string;
     fax?: string;
+    emailAddress: string;
 }
-interface UpdateUserAddressParams extends CreateUserAddressParams {
+/** Text of an optional child element. */
+declare const getInfo: Command<UsersAddressGetInfoParams, UsersAddressGetInfoResult>;
+interface UsersAddressListItem {
     addressId: number;
+    addressName: string;
+    isDefault: boolean;
 }
-
-declare class UsersAddress {
-    private readonly config;
-    constructor(config: NamecheapProps);
-    create(param: CreateUserAddressParams): Promise<AddressCreateResult>;
-    delete(addressId: number): Promise<AddressDeleteResult>;
-    getInfo(addressId: number): Promise<GetAddressInfoResult>;
-    getList(): Promise<AddressGetListResult>;
-    setDefault(addressId: number): Promise<number>;
-    update(addressId: number, params: Omit<UpdateUserAddressParams, "addressId">): Promise<AddressUpdateResult>;
+/** The response has no `Paging` element, so the result is a bare array (empty when there are no `List` elements). */
+type UsersAddressGetListResult = UsersAddressListItem[];
+declare const getList$1: Command<Record<string, never>, UsersAddressGetListResult>;
+interface UsersAddressSetDefaultParams {
+    /** Sent as `AddressId`; 0 makes the primary address the default again. */
+    addressId: number;
+}
+interface UsersAddressSetDefaultResult {
+    success: boolean;
+    addressId: number;
+}
+declare const setDefault: Command<UsersAddressSetDefaultParams, UsersAddressSetDefaultResult>;
+/** Same fields as `create`; omitting `defaultYN` leaves the default flag unchanged. */
+interface UsersAddressUpdateParams extends UsersAddressCreateParams {
+    /** Sent as `AddressId`. */
+    addressId: number;
+}
+interface UsersAddressUpdateResult {
+    success: boolean;
+    addressId: number;
+    addressName: string;
 }
+declare const update: Command<UsersAddressUpdateParams, UsersAddressUpdateResult>;
+/**
+ * The command table behind `client.usersAddress`. Advanced use only: it is exported for custom
+ * integrations and is not covered by semver stability.
+ */
+declare const usersAddressCommands: {
+    create: Command<UsersAddressCreateParams, UsersAddressCreateResult>;
+    delete: Command<UsersAddressDeleteParams, UsersAddressDeleteResult>;
+    getInfo: Command<UsersAddressGetInfoParams, UsersAddressGetInfoResult>;
+    getList: Command<Record<string, never>, UsersAddressGetListResult>;
+    setDefault: Command<UsersAddressSetDefaultParams, UsersAddressSetDefaultResult>;
+    update: Command<UsersAddressUpdateParams, UsersAddressUpdateResult>;
+};
 
-interface WhoIsGuardChangeEmailAddressResult {
+interface WhoisguardChangeEmailAddressParams {
+    /** Unique domain privacy ID to change. Sent as `WhoisguardID`. */
+    whoisguardID: number;
+}
+interface WhoisguardChangeEmailAddressResult {
+    /** Unique integer representing the domain privacy subscription. */
     id: number;
     isSuccess: boolean;
+    /** New domain privacy email address. */
     wgEmail: string;
+    /** Old domain privacy email address. */
     wgOldEmail: string;
 }
-interface WhoIsGuardGetListResult {
-    id: number;
-    created: string;
-    expires: string;
-    status: string;
+declare const changeEmailAddress: Command<WhoisguardChangeEmailAddressParams, WhoisguardChangeEmailAddressResult>;
+interface WhoisguardEnableParams {
+    /** Unique domain privacy ID to enable. Sent as `WhoisguardID`. */
+    whoisguardID: number;
+    /** Email address to forward domain privacy emails to (max 70 characters). */
+    forwardedToEmail: string;
 }
-interface WhoIsGuardRenewResult {
-    whoisguardId: number;
-    years: number;
-    renew: boolean;
-    orderId: number;
-    transactionId: number;
-    chargedAmount: number;
+interface WhoisguardEnableResult {
+    domainName: string;
+    isSuccess: boolean;
 }
-
-interface GetListParams {
-    listType?: WhoIsListType;
+declare const enable: Command<WhoisguardEnableParams, WhoisguardEnableResult>;
+interface WhoisguardDisableParams {
+    /** Unique domain privacy ID to disable. Sent as `WhoisguardID`. */
+    whoisguardID: number;
+}
+interface WhoisguardDisableResult {
+    /** The reference spells this `Domainname`; the fixture uses `DomainName`. */
+    domainName: string;
+    isSuccess: boolean;
+}
+declare const disable: Command<WhoisguardDisableParams, WhoisguardDisableResult>;
+/** `ALLOTED` is the API's own (nonstandard) spelling and is sent verbatim. */
+type WhoisguardListType = "ALL" | "ALLOTED" | "FREE" | "DISCARD";
+interface WhoisguardGetListParams {
+    /** Default: ALL. */
+    listType?: WhoisguardListType;
+    /** Default: 1. */
     page?: number;
+    /** Min 2, max 100. */
     pageSize?: number;
 }
-
-declare class WhoIsGuard {
-    private readonly config;
-    constructor(config: NamecheapProps);
-    changeEmailAddress(whoIsGuardId: number): Promise<WhoIsGuardChangeEmailAddressResult>;
-    enable(whoIsGuardId: number, forwardedToEmail: string): Promise<string>;
-    disable(whoIsGuardId: number): Promise<string>;
-    getList(param: GetListParams): Promise<{
-        data: Array<WhoIsGuardGetListResult>;
-        paging: Paging;
-    }>;
-    renew(whoIsGuardId: string, year: number, promotionCode?: number): Promise<WhoIsGuardRenewResult>;
+interface WhoisguardListItem {
+    /** Unique integer representing the subscription (the reference column is "Whoisguard ID"). */
+    id: number;
+    /** The reference spells this column `Domainname`; the fixture uses `DomainName`. Empty for a FREE subscription. */
+    domainName: string;
+    created: string;
+    expires: string;
+    status: string;
 }
-
-declare class Namecheap {
-    private readonly apiUrl;
-    private readonly apiUser;
-    private readonly apiKey;
-    private readonly username;
-    private readonly clientIp;
-    readonly domains: Domains;
-    readonly domainsDns: DomainsDNS;
-    readonly domainsNs: DomainsNS;
-    readonly domainsTransfer: DomainsTransfer;
-    readonly ssl: SSL;
-    readonly users: Users;
-    readonly usersAddress: UsersAddress;
-    readonly whoIsGuard: WhoIsGuard;
-    get domainPrivacy(): WhoIsGuard;
-    constructor(config: ConfigType);
-    private getConfig;
+interface WhoisguardGetListResult {
+    whoisguards: WhoisguardListItem[];
+    paging: Paging;
+}
+declare const getList: Command<WhoisguardGetListParams, WhoisguardGetListResult>;
+/**
+ * @remarks Billed: this command charges your Namecheap account.
+ */
+interface WhoisguardRenewParams {
+    /** Domain privacy ID to renew. Sent as `WhoisguardID`. */
+    whoisguardID: number;
+    /** Number of years to renew. Default: 1. */
+    years: number;
+    promotionCode?: string;
 }
+interface WhoisguardRenewResult {
+    whoisguardID?: number;
+    years?: number;
+    /** Omitted when the attribute is absent or not `true`/`false`. */
+    renew?: boolean;
+    orderID?: number;
+    transactionID?: number;
+    chargedAmount?: number;
+}
+declare const renew: Command<WhoisguardRenewParams, WhoisguardRenewResult>;
+/**
+ * The command table behind `client.whoisGuard`. Advanced use only: it is exported for custom
+ * integrations and is not covered by semver stability.
+ */
+declare const whoisGuardCommands: {
+    changeEmailAddress: Command<WhoisguardChangeEmailAddressParams, WhoisguardChangeEmailAddressResult>;
+    enable: Command<WhoisguardEnableParams, WhoisguardEnableResult>;
+    disable: Command<WhoisguardDisableParams, WhoisguardDisableResult>;
+    getList: Command<WhoisguardGetListParams, WhoisguardGetListResult>;
+    renew: Command<WhoisguardRenewParams, WhoisguardRenewResult>;
+};
 
-export { DomainDnsTag, DomainListSortBy, DomainListType, DomainTransferListType, DomainTransferSortBy, EmailType, GetAddFundsStatus, IdnCode, LockAction, RecordType, SSLListSortBy, SSLListType, SSLType, UserActionName, UserListFindBy, UserPaymentType, UserProductCategory, UserProductName, UserProductType, WhoIsListType, Namecheap as default };
+export { Namecheap, NamecheapError, NamecheapHttpError, NamecheapParseError, createTransport, Namecheap as default, dnsCommands, getEmailForwarding as dnsGetEmailForwarding, getHosts as dnsGetHosts, getList$4 as dnsGetList, setCustom as dnsSetCustom, setDefault$1 as dnsSetDefault, setEmailForwarding as dnsSetEmailForwarding, setHosts as dnsSetHosts, check as domainsCheck, domainsCommands, create$5 as domainsCreate, getContacts as domainsGetContacts, getInfo$3 as domainsGetInfo, getList$5 as domainsGetList, getRegistrarLock as domainsGetRegistrarLock, getTldList as domainsGetTldList, reactivate as domainsReactivate, renew$2 as domainsRenew, setContacts as domainsSetContacts, setRegistrarLock as domainsSetRegistrarLock, nsCommands, create$4 as nsCreate, deleteNs as nsDelete, getInfo$2 as nsGetInfo, update$2 as nsUpdate, run, activate as sslActivate, sslCommands, create$2 as sslCreate, editDCVMethod as sslEditDCVMethod, getApproverEmailList as sslGetApproverEmailList, getInfo$1 as sslGetInfo, getList$2 as sslGetList, parseCSR as sslParseCSR, purchaseMoreSans as sslPurchaseMoreSans, reissue as sslReissue, renew$1 as sslRenew, resendApproverEmail as sslResendApproverEmail, resendFulfillmentEmail as sslResendFulfillmentEmail, revokeCertificate as sslRevokeCertificate, transferCommands, create$3 as transferCreate, getList$3 as transferGetList, getStatus as transferGetStatus, updateStatus as transferUpdateStatus, usersAddressCommands, create as usersAddressCreate, deleteAddress as usersAddressDelete, getInfo as usersAddressGetInfo, getList$1 as usersAddressGetList, setDefault as usersAddressSetDefault, update as usersAddressUpdate, changePassword as usersChangePassword, usersCommands, create$1 as usersCreate, createAddFundsRequest as usersCreateAddFundsRequest, getAddFundsStatus as usersGetAddFundsStatus, getBalances as usersGetBalances, getPricing as usersGetPricing, login as usersLogin, resetPassword as usersResetPassword, update$1 as usersUpdate, changeEmailAddress as whoisGuardChangeEmailAddress, whoisGuardCommands, disable as whoisGuardDisable, enable as whoisGuardEnable, getList as whoisGuardGetList, renew as whoisGuardRenew };
+export type { Command, DnsEmailForward, DnsEmailForwardRecord, DnsEmailType, DnsGetEmailForwardingParams, DnsGetEmailForwardingResult, DnsGetHostsParams, DnsGetHostsResult, DnsGetListParams, DnsGetListResult, DnsHost, DnsHostRecord, DnsRecordType, DnsSetCustomParams, DnsSetCustomResult, DnsSetDefaultParams, DnsSetDefaultResult, DnsSetEmailForwardingParams, DnsSetEmailForwardingResult, DnsSetHostsParams, DnsSetHostsResult, DomainsCheckItem, DomainsCheckParams, DomainsCheckResult, DomainsContact, DomainsContactParams, DomainsCreateParams, DomainsCreateResult, DomainsGetContactsParams, DomainsGetContactsResult, DomainsGetInfoParams, DomainsGetInfoResult, DomainsGetListParams, DomainsGetListResult, DomainsGetRegistrarLockParams, DomainsGetRegistrarLockResult, DomainsGetTldListResult, DomainsListItem, DomainsListType, DomainsLockAction, DomainsReactivateParams, DomainsReactivateResult, DomainsRenewParams, DomainsRenewResult, DomainsSetContactsParams, DomainsSetContactsResult, DomainsSetRegistrarLockParams, DomainsSetRegistrarLockResult, DomainsSortBy, DomainsTld, TransportConfig as NamecheapConfig, NsCreateParams, NsCreateResult, NsDeleteParams, NsDeleteResult, NsGetInfoParams, NsGetInfoResult, NsUpdateParams, NsUpdateResult, PricingPrice, PricingProduct, PricingProductCategory, PricingProductType, Send, SslActivateParams, SslActivateResult, SslCreateParams, SslCreateResult, SslEditDcvMethodParams, SslEditDcvMethodResult, SslGetApproverEmailListParams, SslGetApproverEmailListResult, SslGetInfoParams, SslGetInfoResult, SslGetListParams, SslGetListResult, SslHttpDcValidation, SslListItem, SslListType, SslParseCsrParams, SslParseCsrResult, SslPurchaseMoreSansParams, SslPurchaseMoreSansResult, SslReissueParams, SslReissueResult, SslRenewParams, SslRenewResult, SslResendApproverEmailParams, SslResendApproverEmailResult, SslResendFulfillmentEmailParams, SslResendFulfillmentEmailResult, SslResendResult, SslReturnType, SslRevokeCertificateParams, SslRevokeCertificateResult, SslSortBy, TransferCreateParams, TransferCreateResult, TransferGetListParams, TransferGetListResult, TransferGetStatusParams, TransferGetStatusResult, TransferListItem, TransferListType, TransferSortBy, TransferUpdateStatusParams, TransferUpdateStatusResult, UsersAddressCreateParams, UsersAddressCreateResult, UsersAddressDeleteParams, UsersAddressDeleteResult, UsersAddressGetInfoParams, UsersAddressGetInfoResult, UsersAddressGetListResult, UsersAddressListItem, UsersAddressSetDefaultParams, UsersAddressSetDefaultResult, UsersAddressUpdateParams, UsersAddressUpdateResult, UsersChangePasswordParams, UsersChangePasswordResult, UsersCreateAddFundsRequestParams, UsersCreateAddFundsRequestResult, UsersCreateParams, UsersCreateResult, UsersGetAddFundsStatusParams, UsersGetAddFundsStatusResult, UsersGetBalancesResult, UsersGetPricingParams, UsersGetPricingResult, UsersLoginParams, UsersLoginResult, UsersPaymentType, UsersResetPasswordFindBy, UsersResetPasswordParams, UsersResetPasswordResult, UsersUpdateParams, UsersUpdateResult, WhoisguardChangeEmailAddressParams, WhoisguardChangeEmailAddressResult, WhoisguardDisableParams, WhoisguardDisableResult, WhoisguardEnableParams, WhoisguardEnableResult, WhoisguardGetListParams, WhoisguardGetListResult, WhoisguardListItem, WhoisguardListType, WhoisguardRenewParams, WhoisguardRenewResult };