@fwgapps/namecheap 0.2.1 → 0.4.0

package/dist/index.d.cts

@@ -1,14 +1,3 @@
-/**
- * The ConfigType interface defines the structure for configuration data used in an application.
- * This could include API credentials, client information, and other optional settings.
- *
- * Properties:
- * - `apiUser`: A string representing the user identifier for API authentication.
- * - `apiKey`: A string containing the authentication key required for API access.
- * - `clientIp`: A string representing the IP address of the client or user making requests.
- * - `sandbox`: A boolean indicating whether the application is running in a sandbox (testing) environment.
- * - `username` (optional): A string specifying the username for additional authentication purposes.
- */
 interface ConfigType {
     apiUser: string;
     apiKey: string;
@@ -16,19 +5,6 @@ interface ConfigType {
     sandbox: boolean;
     username?: string;
 }
-/**
- * Interface representing configuration properties for interacting with the Namecheap API.
- *
- * The properties in this interface are used to authenticate and establish a connection
- * with the Namecheap API, and they include credentials and endpoint details.
- *
- * Properties:
- *   - apiUser: The API user associated with the Namecheap account.
- *   - apiKey: The API key used for authenticating API requests.
- *   - clientIp: The client's IP address allowed to communicate with the API.
- *   - apiUrl: The base URL of the Namecheap API endpoint.
- *   - username: The username of the Namecheap account owner.
- */
 interface NamecheapProps {
     apiUser: string;
     apiKey: string;
@@ -37,15 +13,6 @@ interface NamecheapProps {
     username: string;
 }
 
-/**
- * Represents the pagination details for a dataset.
- *
- * @interface Paging
- * @property {number} totalItem - The total number of items in the dataset.
- * @property {number} currentPage - The current page being accessed.
- * @property {number} pageSize - The number of items displayed per page.
- * @property {boolean} paging - Indicates whether paging is enabled.
- */
 interface Paging {
     totalItem: number;
     currentPage: number;
@@ -66,45 +33,12 @@ interface DomainGetListResult {
     isPremium: boolean;
     isOurDns: boolean;
 }
-/**
- * Represents the collection of contact details associated with different roles.
- *
- * This interface is used to store and structure contact information for
- * registrants, technical contacts, administrative contacts, and auxiliary billing contacts.
- *
- * Each property corresponds to a different role and contains detailed
- * contact information through the `ContactDetail` interface.
- */
 interface Contacts {
     registrant: ContactDetail;
     tech: ContactDetail;
     admin: ContactDetail;
     auxBilling: ContactDetail;
 }
-/**
- * Represents the contact details for an individual or organization.
- *
- * This interface defines the structure for commonly used contact information
- * such as names, addresses, communication details, and additional metadata.
- *
- * Properties:
- * - organizationName: The name of the organization associated with the contact.
- * - jobTitle: The job title or role of the contact individual.
- * - firstName: The first name of the individual contact.
- * - lastName: The last name of the individual contact.
- * - address1: The primary address line for the contact.
- * - address2: The secondary address line, if applicable.
- * - city: The city where the contact is located.
- * - stateProvince: The state or province of the contact's location.
- * - stateProvinceChoice: Specific state or province choice when applicable.
- * - postalCode: The postal or zip code corresponding to the contact's address.
- * - country: The name of the country of the contact.
- * - phone: The primary phone number for the contact.
- * - fax: The fax number associated with the contact, if available.
- * - emailAddress: The primary email address associated with the contact.
- * - phoneExt: The phone number extension, if applicable.
- * - readOnly: A flag indicating whether the contact details are read-only.
- */
 interface ContactDetail {
     organizationName: string;
     jobTitle: string;
@@ -123,14 +57,6 @@ interface ContactDetail {
     phoneExt: number;
     readOnly: boolean;
 }
-/**
- * Represents the attributes related to the current registrant.
- *
- * This interface provides properties that define key details about the
- * registrant's nexus and purpose.
- *
- * @interface
- */
 interface CurrentAttributes {
     registrantNexus: string;
     registrantPurpose: string;
@@ -153,13 +79,6 @@ interface DomainCreateResult {
     whoisguardEnable: boolean;
     nonRealTimeDomain: boolean;
 }
-/**
- * Represents a category with a name and a sequence number.
- *
- * @interface Category
- * @property {string} name - The name of the category.
- * @property {number} sequenceNumber - The sequence number of the category, typically used for ordering.
- */
 interface Category {
     name: string;
     sequenceNumber: number;
@@ -284,72 +203,282 @@ interface DomainGetInfoResult {
     isPremium: boolean;
 }
 
-/**
- * Represents a type that defines a set of standardized language codes.
- * Each language code corresponds to a specific language or dialect typically defined
- * by their internationally recognized abbreviations. These codes follow conventions used
- * in software and internationalization frameworks for language identification.
- */
-type IdnCode = "afr" | "alb" | "ara" | "arg" | "arm" | "asm" | "ast" | "ave" | "awa" | "aze" | "bak" | "bal" | "ban" | "baq" | "bas" | "bel" | "ben" | "bho" | "bos" | "bul" | "bur" | "car" | "cat" | "che" | "chi" | "chv" | "cop" | "cos" | "cze" | "dan" | "div" | "doi" | "dut" | "eng" | "est" | "fao" | "fij" | "fin" | "fre" | "fry" | "geo" | "ger" | "gla" | "gle" | "gon" | "gre" | "guj" | "heb" | "hin" | "hun" | "inc" | "ind" | "inh" | "isl" | "ita" | "jav" | "jpn" | "kas" | "kaz" | "khm" | "kir" | "kor" | "kur" | "lao" | "lav" | "lit" | "ltz" | "mal" | "mkd" | "mlt" | "mol" | "mon" | "mri" | "msa" | "nep" | "nor" | "ori" | "oss" | "pan" | "per" | "pol" | "por" | "pus" | "raj" | "rum" | "rus" | "san" | "scr" | "sin" | "slo" | "slv" | "smo" | "snd" | "som" | "spa" | "srd" | "srp" | "swa" | "swe" | "syr" | "tam" | "tel" | "tgk" | "tha" | "tib" | "tur" | "ukr" | "urd" | "uzb" | "vie" | "wel" | "yid";
-/**
- * Represents a predefined type of list used for categorization or filtering.
- *
- * "ALL" - Represents all items in the list without any filtering.
- * "EXPIRING" - Represents items that are nearing their expiration or due date.
- * "EXPIRED" - Represents items that have already passed their expiration or due date.
- */
-type ListType$3 = "ALL" | "EXPIRING" | "EXPIRED";
-/**
- * SortBy represents the sorting options for a collection of items.
- * Each option specifies an attribute to sort by and the sort order.
- *
- * - "NAME": Sort by name in ascending order.
- * - "NAME_DESC": Sort by name in descending order.
- * - "EXPIREDATE": Sort by expiration date in ascending order.
- * - "EXPIREDATE_DESC": Sort by expiration date in descending order.
- * - "CREATEDATE": Sort by creation date in ascending order.
- * - "CREATEDATE_DESC": Sort by creation date in descending order.
- */
-type SortBy$2 = "NAME" | "NAME_DESC" | "EXPIREDATE" | "EXPIREDATE_DESC" | "CREATEDATE" | "CREATEDATE_DESC";
-/**
- * Represents the parameters for obtaining a list with optional filters and pagination.
- *
- * @interface GetListParams
- *
- * @property {ListType} [listType] The type of list to retrieve; optional.
- * @property {string} [searchTerm] A search query to filter the list; optional.
- * @property {number} [page] The page number for paginated results; optional.
- * @property {number} [pageSize] The number of items per page for paginated results; optional.
- * @property {SortBy} [sortBy] The sorting criteria for the list; optional.
- */
+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";
+};
+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?: ListType$3;
+    listType?: DomainListType;
     searchTerm?: string;
     page?: number;
     pageSize?: number;
-    sortBy?: SortBy$2;
-}
-/**
- * Represents the details required to create a new domain registration.
- *
- * This interface extends the `Contacts` interface, inheriting contact information properties.
- * It includes properties for specifying domain details, registration duration, billing information,
- * and other settings or attributes related to the domain.
- *
- * Properties:
- * - `domainName`: The name of the domain to be registered.
- * - `years`: The number of years for which the domain will be registered.
- * - `promoCode`: (Optional) A promotional code that might be applied during registration.
- * - `billing`: (Optional) Billing contact details provided as a partial contact detail object.
- * - `idnCode`: (Optional) Internationalized domain name code, if applicable.
- * - `extendedAttributes`: Attributes extended for domain registration based on requirements.
- * - `nameservers`: (Optional) Name servers assigned to the domain.
- * - `addFreeWhoisguard`: (Optional) Specifies if free WHOIS Guard should be added.
- * - `WGEnabled`: (Optional) Indicates if WHOIS Guard is enabled for the domain.
- * - `isPremiumDomain`: (Optional) Denotes whether the domain is a premium domain.
- * - `premiumPrice`: (Optional) The price of the premium domain, if applicable.
- * - `eapPrice`: (Optional) Early access pricing for the domain, if in an early access phase.
- */
+    sortBy?: DomainListSortBy;
+}
 interface CreateDomainParams extends Contacts {
     domainName: string;
     years: number;
@@ -364,27 +493,10 @@ interface CreateDomainParams extends Contacts {
     premiumPrice?: number;
     eapPrice?: number;
 }
-/**
- * Represents a contact domain that extends the base Contacts interface.
- * It includes additional attributes specific to domain-level contacts.
- *
- * @interface ContactDomainParams
- * @extends Contacts
- */
 interface ContactDomainParams extends Contacts {
     domainName: string;
     extendedAttributes: string;
 }
-/**
- * Represents the details required to reactivate a domain.
- *
- * @interface ReactivateDomainParams
- * @property {string} domainName - The name of the domain to be reactivated.
- * @property {string} [promotionCode] - Optional promotion code to be applied during reactivation.
- * @property {number} [yearsToAdd] - Optional number of years to extend the domain registration upon reactivation.
- * @property {boolean} [isPremiumDomain] - Indicates if the domain is a premium domain.
- * @property {number} [premiumPrice] - The cost associated with reactivating a premium domain, if applicable.
- */
 interface ReactivateDomainParams {
     domainName: string;
     promotionCode?: string;
@@ -392,17 +504,6 @@ interface ReactivateDomainParams {
     isPremiumDomain?: boolean;
     premiumPrice?: number;
 }
-/**
- * Represents the data required to renew a domain.
- *
- * @interface RenewDomainParams
- *
- * @property {string} domainName - The name of the domain to be renewed.
- * @property {number} years - The number of years for which the domain should be renewed.
- * @property {string} [promotionCode] - An optional promotional code to apply during renewal.
- * @property {boolean} [isPremiumDomain] - Indicates if the domain is a premium domain.
- * @property {number} [premiumPrice] - The price of the premium domain, if applicable.
- */
 interface RenewDomainParams {
     domainName: string;
     years: number;
@@ -410,138 +511,28 @@ interface RenewDomainParams {
     isPremiumDomain?: boolean;
     premiumPrice?: number;
 }
-/**
- * Represents an action that can be performed to modify a lock state.
- *
- * The `LockAction` type can either be:
- * - "LOCK": Represents an action to lock.
- * - "UNLOCK": Represents an action to unlock.
- */
-type LockAction = "LOCK" | "UNLOCK";
-/**
- * Represents the structure required to set or manage a registrar lock for a domain.
- * The registrar lock prevents unauthorized transfer or modification of the domain.
- *
- * @interface SetRegistrarLockParams
- *
- * @property {string} domainName - The fully qualified domain name (FQDN) to which the registrar lock action will be applied.
- *
- * @property {LockAction} lockAction - Specifies the action to be performed on the registrar lock, such as enabling or disabling it.
- */
 interface SetRegistrarLockParams {
     domainName: string;
     lockAction: LockAction;
 }
-/**
- * Represents a structure to store information about a domain and its host.
- *
- * @interface GetInfoParams
- * @property {string} domainName - The name of the domain.
- * @property {string} [hostName] - The optional name of the host associated with the domain.
- */
-interface GetInfoParams {
-    domainName: string;
-    hostName?: string;
-}
 
-/**
- * The `Domains` class provides methods to interact with domain-related functionalities
- * using the Namecheap API. It allows performing operations such as retrieving domain lists,
- * managing contacts, checking availability, and managing domain statuses.
- */
 declare class Domains {
     private readonly config;
     constructor(config: NamecheapProps);
-    /**
-     * Retrieves a list of domains or related items based on the specified parameters.
-     *
-     * @param {Object} params - The parameters to configure the list retrieval.
-     * @param {string} [params.listType="ALL"] - The type of list to retrieve (e.g., ALL, EXPIRING, etc.).
-     * @param {number} [params.page=1] - The page number of the results to retrieve.
-     * @param {number} [params.pageSize=20] - The number of items to retrieve per page.
-     * @return {Promise<NamecheapXMLParsedSuccess<GetListSuccess>>} A promise that resolves with the parsed response data.
-     */
     getList(params?: GetListParams$1): Promise<{
         data: Array<DomainGetListResult>;
         paging: Paging;
     }>;
-    /**
-     * Retrieves the contact information associated with the given domain name.
-     *
-     * @param {string} domainName - The domain name for which to retrieve contact information.
-     * @return {Promise<NamecheapXMLParsedSuccess<GetContactSuccess>>} A promise that resolves with the parsed response containing the contact details.
-     */
     getContacts(domainName: string): Promise<DomainContactsResult>;
-    /**
-     * Creates a new domain registration with the provided parameters.
-     *
-     * @param {string} domain - The domain name to be created.
-     * @param {Omit<CreateDomainParams, "domainName">} params - The parameters required for domain creation, excluding the domain name.
-     * @return {Promise<NamecheapXMLParsedSuccess<CreateSuccess>>} A promise that resolves with the result of the domain creation process.
-     */
     create(domain: string, params: Omit<CreateDomainParams, "domainName">): Promise<DomainCreateResult>;
-    /**
-     * Retrieves the list of top-level domains (TLDs) available from the Namecheap API.
-     *
-     * @return {Promise<NamecheapXMLParsedSuccess<GetTldListSuccess>>} A promise that resolves with the structured response data containing the details of available TLDs.
-     */
     getTldList(): Promise<Array<TLD>>;
-    /**
-     * Updates the contact details for a specific domain.
-     *
-     * @param {string} domain - The domain name for which the contact information will be updated.
-     * @param {Omit<ContactDomainParams, "domainName">} params - The contact information to set, omitting the domain name property.
-     * @return {Promise<NamecheapXMLParsedSuccess<SetContactSuccess>>} A promise that resolves to the result of the contact update operation.
-     */
     setContacts(domain: string, params: Omit<ContactDomainParams, "domainName">): Promise<string>;
-    /**
-     * Checks the availability of the given list of domains.
-     *
-     * @param {Array<string>} domains - An array of domain names to check for availability.
-     * @return {Promise<NamecheapXMLParsedSuccess<CheckSuccess>>} A promise that resolves to the parsed response indicating the availability status of each domain.
-     */
     check(domains: Array<string>): Promise<DomainCheckResult>;
-    /**
-     * Reactivates a previously expired or deactivated domain.
-     *
-     * @param {string} domain - The name of the domain to be reactivated.
-     * @param {Omit<ReactivateDomainParams, "domainName">} [params={}] - Additional parameters for reactivation, excluding the domain name.
-     * @return {Promise<NamecheapXMLParsedSuccess<ReactiveSuccess>>} A promise that resolves with the result of the domain reactivation.
-     */
     reactivate(domain: string, params?: Omit<ReactivateDomainParams, "domainName">): Promise<DomainReactivateResult>;
-    /**
-     * Renews the registration of a domain name with the specified parameters.
-     *
-     * @param {string} domain - The domain name to be renewed.
-     * @param {Omit<RenewDomainParams, "domainName">} params - The parameters required for renewing the domain, excluding the domain name.
-     * @return {Promise<NamecheapXMLParsedSuccess<RenewSuccess>>} A promise that resolves with the parsed response data indicating the success of the renewal.
-     */
     renew(domain: string, params: Omit<RenewDomainParams, "domainName">): Promise<DomainRenewResult>;
-    /**
-     * Retrieves the registrar lock status of the specified domain.
-     *
-     * @param {string} domain - The domain name for which the registrar lock status is being retrieved.
-     * @return {Promise<NamecheapXMLParsedSuccess<GetRegistrarLockSuccess>>} A promise that resolves to the parsed success response containing the registrar lock status.
-     */
     getRegistrarLock(domain: string): Promise<DomainGetRegistrarLockResult>;
-    /**
-     * Sets the registrar lock status for a specified domain.
-     *
-     * @param {string} domain - The domain name for which the registrar lock status is being set.
-     * @param {Object} params - Additional configuration options for the registrar lock action.
-     *                          Defaults to `{ lockAction: "LOCK" }`. Excludes the "domainName" property.
-     * @return {Promise<NamecheapXMLParsedSuccess<SetRegistrarLockSuccess>>} A promise that resolves with the parsed response
-     *         indicating the success or failure of the operation.
-     */
     setRegistrarLock(domain: string, params?: Omit<SetRegistrarLockParams, "domainName">): Promise<DomainSetRegistrarLockResult>;
-    /**
-     * Retrieves information about a specific domain.
-     *
-     * @param {string} domain - The domain name for which information is to be retrieved.
-     * @param {Omit<GetInfoParams, "domainName">} [params={}] - Additional parameters for the request, excluding the domain name.
-     * @return {Promise<NamecheapXMLParsedSuccess<GetInfoSuccess>>} A promise that resolves to the parsed response containing domain information.
-     */
-    getInfo(domain: string, params?: Omit<GetInfoParams, "domainName">): Promise<DomainGetInfoResult>;
+    getInfo(domain: string, hostName?: string): Promise<DomainGetInfoResult>;
 }
 
 interface DomainDnsGetListResult {
@@ -573,28 +564,8 @@ interface DomainDnsGetEmailForwardingResult {
 
 interface SetDNSEmailForwardingParams {
     domainName: string;
-    MailBox: Array<string>;
-    ForwardTo: Array<string>;
-}
-declare enum RecordType {
-    A = "A",
-    AAAA = "AAAA",
-    ALIAS = "ALIAS",
-    CAA = "CAA",
-    CNAME = "CNAME",
-    MX = "MX",
-    MXE = "MXE",
-    NS = "NS",
-    TXT = "TXT",
-    URL = "URL",
-    URL301 = "URL301",
-    FRAME = "FRAME"
-}
-declare enum EmailType {
-    MXE = "MXE",
-    MX = "MX",
-    FWD = "FWD",
-    OX = "OX"
+    mailBox: Array<string>;
+    forwardTo: Array<string>;
 }
 interface Host {
     hostname: string;
@@ -608,7 +579,7 @@ interface SetDNSHostsParams {
     tld: string;
     emailType?: EmailType;
     flag?: number;
-    tag?: string;
+    tag?: DomainDnsTag;
     hostname: Array<string>;
     ttl: Array<number>;
     address: Array<string>;
@@ -618,16 +589,107 @@ interface SetDNSHostsParams {
 
 declare class DomainsDNS {
     private readonly config;
+    /**
+     * @constructor initial configuration to use global settings
+     * @param {NamecheapProps} config Namecheap credentials
+     */
     constructor(config: NamecheapProps);
+    /**
+     * Sets domain to use our default DNS servers.
+     * Required for free services like Host record management, URL forwarding, email forwarding, dynamic dns and other value added services.
+     * @param {string} sld SLD of the DomainName
+     * @param {string} tld TLD of the DomainName
+     * @returns {Promise<>string>} Returns the domain name that you are trying to set default nameservers for.
+     */
     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
+     * @param {string} sld SLD of the DomainName
+     * @param {string} tld TLD of the DomainName
+     * @param {Array<string>} nameservers A list of name servers to be associated with this domain
+     * @returns {Promise<string>} Returns the domain name that you are trying to set custom nameservers for.
+     */
     setCustom(sld: string, tld: string, nameservers: Array<string>): Promise<string>;
+    /**
+     * Gets a list of DNS servers associated with the requested domain.
+     * @param {string} sld SLD of the DomainName
+     * @param {string} tld TLD of the DomainName
+     * @returns List of DNS info (see {@link DomainDnsGetListResult})
+     */
     getList(sld: string, tld: string): Promise<DomainDnsGetListResult>;
+    /**
+     * Retrieves DNS host record settings for the requested domain.
+     * @param {string} sld SLD of the DomainName
+     * @param {string} tld TLD of the DomainName
+     * @returns DNS host records info (see {@link DomainDnsGetHostsResult})
+     */
     getHosts(sld: string, tld: string): Promise<DomainDnsGetHostsResult>;
+    /**
+     * Gets email forwarding settings for the requested domain.
+     * @param {string} domain Domain name to get settings
+     * @returns Email forwarding info (see {@link DomainDnsGetEmailForwardingResult})
+     */
     getEmailForwarding(domain: string): Promise<DomainDnsGetEmailForwardingResult>;
+    /**
+     * Sets email forwarding for a domain name.
+     * @param {string} domain Domain name to set settings
+     * @param {SetDNSEmailForwardingParams} params Set mailbox and forwards
+     * - mailBox: for which you wish to set email forwarding.
+     * - forwardTo: Email address to forward to
+     * @example
+     * setEmailForwarding("mydomain.com", {
+     *    mailBox: ["example@namecheap.com"],
+     *    forwardTo: ["example:example@gmail.com"]
+     *  })
+     *  @returns Return email affected
+     */
     setEmailForwarding(domain: string, params: Omit<SetDNSEmailForwardingParams, "domainName">): Promise<string>;
-    setHosts(sld: string, tld: string, params: Omit<SetDNSHostsParams, "sld" | "tld"> & {
+    /**
+     * 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.
+     * @param {string} sld
+     * @param {string} tld
+     * @param {Omit<
+     *       SetDNSHostsParams,
+     *       "sld" | "tld" | "address" | "hostname" | "mxpref" | "recordType" | "ttl"
+     *     > & { hosts: Array<Host> }} params Host record configuration object:
+     *  - emailType?: The type of email service to use.
+     *    - MXE: to set up your custom MXE record.
+     *    - MX: to set up custom MX records of your mail provider.
+     *    - FWD: to set up MX records for our Free Email Forwarding service.
+     *    - OX: to set up MX records for our Private Email service.
+     *  - flag?: Is an unsigned integer between 0 and 255. The flag value is an 8-bit number, the most significant bit of which indicates the criticality of understanding of a record by a CA. It's recommended to use `0`
+     *  - tag?: A non-zero sequence of US-ASCII letters and numbers in lower case. The tag value can be one of the following values:
+     *    - issue — specifies the certification authority that is authorized to issue a certificate for the domain name or subdomain record used in the title.
+     *    - issuewild — specifies the certification authority that is allowed to issue a wildcard certificate for the domain name or subdomain record used in the title. The certificate applies to the domain name or subdomain directly and to all its subdomains.
+     *    - iodef — specifies the e-mail address or URL (compliant with RFC 5070) a CA should use to notify a client if any issuance policy violation spotted by this CA.
+     * - hosts: Array with host properties
+     *  - hostname: Sub-domain/hostname to create the record for
+     *  - recordType: Record type to that host, possible values
+     *    - A
+     *    - AAAA
+     *    - ALIAS
+     *    - CAA
+     *    - CNAME
+     *    - MX
+     *    - MXE
+     *    - NS
+     *    - TXT
+     *    - URL
+     *    - URL301
+     *    - FRAME
+     *  - address: The value for this parameter is based on RecordType. Possible values:
+     *    - URL
+     *    - IP address
+     *  - mxpref?: MX preference for host. Applicable for MX records only.
+     *  - ttl?: Time to live for all record types.
+     *  @returns Return host list affected
+     */
+    setHosts(sld: string, tld: string, params: Omit<SetDNSHostsParams, "sld" | "tld" | "address" | "hostname" | "mxpref" | "recordType" | "ttl"> & {
         hosts: Array<Host>;
-    }): Promise<string>;
+    }): Promise<Array<string>>;
 }
 
 interface GenericDomain {
@@ -659,20 +721,6 @@ declare class DomainsNS {
     update(sld: string, tld: string, nameserver: string, ip: string, oldIp: string): Promise<DomainNsUpdateResult>;
 }
 
-declare enum ListType$2 {
-    ALL = "ALL",
-    InProgress = "INPROGRESS",
-    Cancelled = "CANCELLED",
-    Completed = "COMPLETED"
-}
-declare enum SortBy$1 {
-    DomainName = "DOMAINNAME",
-    DomainNameDesc = "DOMAINNAME_DESC",
-    TransferDate = "TRANSFERDATE",
-    TransferDateDesc = "TRANSFERDATE_DESC",
-    StatusDate = "STATUSDATE",
-    StatusDateDesc = "STATUSDATE_DESC"
-}
 interface CreateTransferParams {
     domainName: string;
     years: number;
@@ -682,11 +730,11 @@ interface CreateTransferParams {
     wGenable: boolean;
 }
 interface GetListTransferParams {
-    listType?: ListType$2;
+    listType?: DomainTransferListType;
     searchTerm?: string;
     page?: number;
     pageSize?: number;
-    sortBy?: SortBy$1;
+    sortBy?: DomainTransferSortBy;
 }
 
 interface DomainTransferCreateResult {
@@ -728,56 +776,19 @@ declare class DomainsTransfer {
     }>;
 }
 
-declare enum SSLType {
-    PositiveSSL = "PositiveSSL",
-    EssentialSSL = "EssentialSSL",
-    InstantSSL = "InstantSSL",
-    InstantSSLPro = "InstantSSL Pro",
-    PremiumSSL = "PremiumSSL",
-    EVSSL = "EV SSL",
-    PositiveSSLWildcard = "PositiveSSL Wildcard",
-    EssentialSSLWildcard = "EssentialSSL Wildcard",
-    PremiumSSLWildcard = "PremiumSSL Wildcard",
-    PositiveSSLMultiDomain = "PositiveSSL Multi Domain",
-    MultiDomainSSL = "Multi Domain SSL",
-    UnifiedCommunications = "Unified Communications",
-    EVMultiDomainSSL = "EV Multi Domain SSL"
-}
+type CreateSSLYearLimit = 1 | 2 | 3 | 4 | 5;
 interface CreateSSLParams {
-    year: 1 | 2 | 3 | 4 | 5;
+    year: CreateSSLYearLimit;
     type: SSLType;
     sansToADD?: number;
     promotionCode?: string;
 }
-declare enum ListType$1 {
-    ALL = "ALL",
-    Processing = "Processing",
-    EmailSent = "EmailSent",
-    TechnicalProblem = "TechnicalProblem",
-    InProgress = "InProgress",
-    Completed = "Completed",
-    Deactivated = "Deactivated",
-    Active = "Active",
-    Cancelled = "Cancelled",
-    NewPurchase = "NewPurchase",
-    NewRenewal = "NewRenewal"
-}
-declare enum SortBy {
-    PurchaseDate = "PURCHASEDATE",
-    PurchaseDateDesc = "PURCHASEDATE_DESC",
-    SSLType = "SSLTYPE",
-    SSLTypeDesc = "SSLTYPE_DESC",
-    ExpireDateTime = "EXPIREDATETIME",
-    ExpireDateTimeDesc = "EXPIREDATETIME_DESC",
-    Hostname = "Host_Name",
-    HostnameDesc = "Host_Name_DESC"
-}
 interface GetListSSLParams {
-    listType?: ListType$1;
+    listType?: SSLListType;
     searchTerm?: string;
     page?: number;
     pageSize?: number;
-    sortBy?: SortBy;
+    sortBy?: SSLListSortBy;
 }
 interface ActivateSSLCommonParams {
     certificateId: number;
@@ -985,31 +996,12 @@ declare class SSL {
     editDCVMethod(certificateId: number, params: Omit<EditDCVMethodParams, "certificateId">): Promise<SSLEditDcvMethodResult>;
 }
 
-declare enum ProductType {
-    Domain = "DOMAIN",
-    SslCertificate = "SSLCERTIFICATE"
-}
-declare enum ProductCategory$1 {
-    Domains = "DOMAINS",
-    Comodo = "COMODO"
-}
-declare enum ActionName {
-    Register = "REGISTER",
-    Renew = "RENEW",
-    Reactivate = "REACTIVATE",
-    Transfer = "TRANSFER",
-    Purchase = "PURCHASE"
-}
-declare enum ProductName {
-    COM = "COM",
-    InstantSsl = "INSTANTSSL"
-}
 interface GetPricingUserParams {
-    productType: ProductType;
-    productCategory?: ProductCategory$1;
+    productType: UserProductType;
+    productCategory?: UserProductCategory;
     promotionCode?: string;
-    actionName?: ActionName;
-    productName?: ProductName;
+    actionName?: UserActionName;
+    productName?: UserProductName;
 }
 interface UpdateParams {
     firstName: string;
@@ -1027,10 +1019,9 @@ interface UpdateParams {
     phoneExt?: string;
     fax?: string;
 }
-type PaymentType = "Creditcard";
 interface CreateAddFundsRequestParams {
     username: string;
-    paymentType: PaymentType;
+    paymentType: typeof UserPaymentType.CreditCard;
     amount: number;
     returnUrl: string;
 }
@@ -1055,13 +1046,8 @@ interface CreateUserParams {
     phoneExt?: string;
     fax?: string;
 }
-declare enum FindBy {
-    EmailAddress = "EMAILADDRESS",
-    DomainName = "DOMAINNAME",
-    Username = "USERNAME"
-}
 interface ResetPasswordParams {
-    findBy: FindBy;
+    findBy: UserListFindBy;
     findByValue: string;
     emailFromName?: string;
     emailFrom?: string;
@@ -1097,13 +1083,6 @@ interface UserCreateAddFundsRequest {
     returnUrl: string;
     redirectUrl: string;
 }
-declare enum GetAddFundsStatus {
-    Created = "CREATED",
-    Submitted = "SUBMITTED",
-    Completed = "COMPLETED",
-    Failed = "FAILED",
-    Expired = "EXPIRED"
-}
 interface GetAddFundsStatusResult {
     transactionId: number;
     amount: number;
@@ -1221,14 +1200,8 @@ interface WhoIsGuardRenewResult {
     chargedAmount: number;
 }
 
-declare enum ListType {
-    All = "ALL",
-    Alloted = "ALLOTED",
-    Free = "FREE",
-    Discard = "DISCARD"
-}
 interface GetListParams {
-    listType?: ListType;
+    listType?: WhoIsListType;
     page?: number;
     pageSize?: number;
 }
@@ -1265,4 +1238,4 @@ declare class Namecheap {
     private getConfig;
 }
 
-export { Namecheap as default };
+export { DomainDnsTag, DomainListSortBy, DomainListType, DomainTransferListType, DomainTransferSortBy, EmailType, GetAddFundsStatus, IdnCode, LockAction, RecordType, SSLListSortBy, SSLListType, SSLType, UserActionName, UserListFindBy, UserPaymentType, UserProductCategory, UserProductName, UserProductType, WhoIsListType, Namecheap as default };