@fwgapps/namecheap 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,1268 @@
+/**
+ * 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;
+    clientIp: string;
+    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;
+    clientIp: string;
+    apiUrl: string;
+    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;
+    pageSize: number;
+    paging: boolean;
+}
+
+interface DomainGetListResult {
+    id: number;
+    name: string;
+    user: string;
+    created: string;
+    expires: string;
+    isExpired: boolean;
+    isLocked: boolean;
+    autoRenew: boolean;
+    whoisGuard: string;
+    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;
+    firstName: string;
+    lastName: string;
+    address1: string;
+    address2: string;
+    city: string;
+    stateProvince: string;
+    stateProvinceChoice: string;
+    postalCode: number;
+    country: string;
+    phone: number;
+    fax: number;
+    emailAddress: string;
+    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;
+}
+interface DomainContactsResult extends Contacts {
+    currentAttributes: CurrentAttributes;
+    whoisGuardContact: Contacts & {
+        whoisGuardContact: boolean;
+    };
+    domain: string;
+    domainnameid: number;
+}
+interface DomainCreateResult {
+    domain: string;
+    registered: boolean;
+    chargedAmount: number;
+    domainID: number;
+    orderID: number;
+    transactionID: number;
+    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;
+}
+interface TLD {
+    name: string;
+    nonRealTime: 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;
+}
+interface DomainRenewResult {
+    domainDetails: {
+        expiredDate: string;
+        numYears: number;
+        domainDetails: boolean;
+    };
+    domainName: string;
+    domainId: number;
+    renew: true;
+    orderId: number;
+    transactionId: number;
+    chargedAmount: number;
+}
+interface DomainGetRegistrarLockResult {
+    domain: string;
+    registrarLockStatus: boolean;
+    isClientUpdateProhibited: boolean;
+    isClientDeleteProhibited: boolean;
+    isClientHold: boolean;
+}
+interface DomainSetRegistrarLockResult {
+    domain: string;
+    isSuccess: boolean;
+    registrarLockStatus: boolean;
+    isRegistrarLockStatusUpdated: boolean;
+    isClientUpdateProhibitedUpdated: boolean;
+    isClientDeleteProhibitedUpdated: boolean;
+    isClientHoldUpdated: boolean;
+}
+interface DomainGetInfoResult {
+    domainDetails: {
+        createdDate: string;
+        expiredDate: string;
+        numYears: number;
+        domainDetails: boolean;
+    };
+    whoisguard: {
+        id: number;
+        enabled: string;
+    };
+    premiumDnsSubscription: {
+        useAutoRenew: boolean;
+        subscriptionId: number;
+        createdDate: string;
+        expirationDate: string;
+        isActive: boolean;
+        premiumDnsSubscription: boolean;
+    };
+    dnsDetails: {
+        nameserver: Array<string>;
+        providerType: string;
+        isUsingOurDns: boolean;
+        hostCount: number;
+        emailType: string;
+        dynamicDnsStatus: boolean;
+        isFailover: boolean;
+    };
+    modificationrights: {
+        all: boolean;
+    };
+    status: string;
+    id: number;
+    domainName: string;
+    ownerName: string;
+    isOwner: boolean;
+    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.
+ */
+interface GetListParams$1 {
+    listType?: ListType$3;
+    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.
+ */
+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;
+    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;
+    yearsToAdd?: number;
+    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;
+    promotionCode?: string;
+    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>;
+}
+
+interface DomainDnsGetListResult {
+    nameserver: Array<string>;
+    domain: string;
+    isUsingOurDns: boolean;
+}
+interface Host$1 {
+    hostId: number;
+    name: string;
+    type: string;
+    address: string;
+    mxPref: number;
+    ttl: number;
+}
+interface DomainDnsGetHostsResult {
+    host: Array<Host$1>;
+    domain: string;
+    isUsingOurDns: boolean;
+}
+interface Forward {
+    value: string;
+    mailbox: string;
+}
+interface DomainDnsGetEmailForwardingResult {
+    forward: Array<Forward>;
+    domain: string;
+}
+
+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"
+}
+interface Host {
+    hostname: string;
+    recordType: RecordType;
+    address: string;
+    mxpref?: string;
+    ttl?: number;
+}
+interface SetDNSHostsParams {
+    sld: string;
+    tld: string;
+    emailType?: EmailType;
+    flag?: number;
+    tag?: string;
+    hostname: Array<string>;
+    ttl: Array<number>;
+    address: Array<string>;
+    mxpref: Array<string>;
+    recordType: Array<RecordType>;
+}
+
+declare class DomainsDNS {
+    private readonly config;
+    constructor(config: NamecheapProps);
+    setDefault(sld: string, tld: string): Promise<string>;
+    setCustom(sld: string, tld: string, nameservers: Array<string>): Promise<string>;
+    getList(sld: string, tld: string): Promise<DomainDnsGetListResult>;
+    getHosts(sld: string, tld: string): Promise<DomainDnsGetHostsResult>;
+    getEmailForwarding(domain: string): Promise<DomainDnsGetEmailForwardingResult>;
+    setEmailForwarding(domain: string, params: Omit<SetDNSEmailForwardingParams, "domainName">): Promise<string>;
+    setHosts(sld: string, tld: string, params: Omit<SetDNSHostsParams, "sld" | "tld"> & {
+        hosts: Array<Host>;
+    }): Promise<string>;
+}
+
+interface GenericDomain {
+    domain: string;
+    nameserver: string;
+}
+interface DomainNsCreateResult extends GenericDomain {
+    ip: string;
+    isSuccess: boolean;
+}
+interface DomainNsDeleteResult extends GenericDomain {
+    isSuccess: boolean;
+}
+interface DomainNsInfoResult extends GenericDomain {
+    nameserverStatuses: Array<string>;
+}
+interface DomainNsUpdateResult {
+    domain: string;
+    nameserverStatuses: Array<string>;
+    isSuccess: boolean;
+}
+
+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 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;
+    eppCode: string;
+    promotionCode: string;
+    addFreeWhoisGuard: boolean;
+    wGenable: boolean;
+}
+interface GetListTransferParams {
+    listType?: ListType$2;
+    searchTerm?: string;
+    page?: number;
+    pageSize?: number;
+    sortBy?: SortBy$1;
+}
+
+interface DomainTransferCreateResult {
+    domainname: string;
+    transfer: boolean;
+    transferId: number;
+    statusId: number;
+    orderId: number;
+    transactionId: number;
+    chargedAmount: number;
+    statusCode: number;
+}
+interface DomainTransferGetStatusResult {
+    transferId: number;
+    status: string;
+    statusId: number;
+}
+interface TransferGetResult {
+    id: number;
+    domainname: string;
+    user: string;
+    transferDate: string;
+    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;
+    }>;
+}
+
+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"
+}
+interface CreateSSLParams {
+    year: 1 | 2 | 3 | 4 | 5;
+    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;
+    searchTerm?: string;
+    page?: number;
+    pageSize?: number;
+    sortBy?: SortBy;
+}
+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;
+}
+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;
+    hostName: string;
+    sslType: string;
+    purchaseDate: string;
+    expireDate: string;
+    activationExpireDate: string;
+    isExpiredYn: boolean;
+    status: 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;
+}
+interface SSLActivateResult {
+    httpDcValidation: {
+        fileName: string;
+        fileContent: string;
+        domain: string;
+    };
+    dnsdcValidation: {
+        hostName: string;
+        target: string;
+        domain: string;
+    };
+    id: number;
+    isSuccess: boolean;
+}
+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;
+}
+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;
+    };
+    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>;
+}
+
+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;
+    promotionCode?: string;
+    actionName?: ActionName;
+    productName?: ProductName;
+}
+interface UpdateParams {
+    firstName: string;
+    lastName: string;
+    jobTitle?: string;
+    organization?: string;
+    address1: string;
+    address2?: string;
+    city: string;
+    stateProvince: string;
+    zip: string;
+    country: string;
+    emailAddress: string;
+    phone: string;
+    phoneExt?: string;
+    fax?: string;
+}
+type PaymentType = "Creditcard";
+interface CreateAddFundsRequestParams {
+    username: string;
+    paymentType: PaymentType;
+    amount: number;
+    returnUrl: string;
+}
+interface CreateUserParams {
+    newUserName: string;
+    newUserPassword: string;
+    emailAddress: string;
+    ignoreDuplicateEmailAddress?: string;
+    firstName: string;
+    lastName: string;
+    acceptTerms: number;
+    acceptNews?: number;
+    jobTitle?: string;
+    organization?: string;
+    address1: string;
+    address2?: string;
+    city: string;
+    stateProvince: string;
+    zip: string;
+    country: string;
+    phone: string;
+    phoneExt?: string;
+    fax?: string;
+}
+declare enum FindBy {
+    EmailAddress = "EMAILADDRESS",
+    DomainName = "DOMAINNAME",
+    Username = "USERNAME"
+}
+interface ResetPasswordParams {
+    findBy: FindBy;
+    findByValue: string;
+    emailFromName?: string;
+    emailFrom?: string;
+    urlPattern?: string;
+}
+
+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;
+}
+declare enum GetAddFundsStatus {
+    Created = "CREATED",
+    Submitted = "SUBMITTED",
+    Completed = "COMPLETED",
+    Failed = "FAILED",
+    Expired = "EXPIRED"
+}
+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;
+    addressName: string;
+    defaultYn: boolean;
+    firstName: string;
+    lastName: string;
+    jobTitle: string;
+    organization: string;
+    address1: string;
+    address2: string;
+    city: string;
+    stateProvince: string;
+    stateProvinceChoice: string;
+    zip: number;
+    country: string;
+    phone: number;
+    fax: number;
+    phoneExt: number;
+    emailAddress: string;
+    getAddressInfoResult: boolean;
+}
+interface AddressGetListResult {
+    addressId: number;
+    addressName: string;
+}
+interface AddressUpdateResult {
+    success: boolean;
+    addressId: number;
+    addressName: string;
+}
+
+interface CreateUserAddressParams {
+    addressName: string;
+    defaultYN?: number;
+    emailAddress: string;
+    firstName: string;
+    lastName: string;
+    jobTitle?: string;
+    organization?: string;
+    address1: string;
+    address2?: string;
+    city: string;
+    stateProvince: string;
+    stateProvinceChoice: string;
+    zip: string;
+    country: string;
+    phone: string;
+    phoneExt?: string;
+    fax?: string;
+}
+interface UpdateUserAddressParams extends CreateUserAddressParams {
+    addressId: number;
+}
+
+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>;
+}
+
+interface WhoIsGuardChangeEmailAddressResult {
+    id: number;
+    isSuccess: boolean;
+    wgEmail: string;
+    wgOldEmail: string;
+}
+interface WhoIsGuardGetListResult {
+    id: number;
+    created: string;
+    expires: string;
+    status: string;
+}
+interface WhoIsGuardRenewResult {
+    whoisguardId: number;
+    years: number;
+    renew: boolean;
+    orderId: number;
+    transactionId: number;
+    chargedAmount: number;
+}
+
+declare enum ListType {
+    All = "ALL",
+    Alloted = "ALLOTED",
+    Free = "FREE",
+    Discard = "DISCARD"
+}
+interface GetListParams {
+    listType?: ListType;
+    page?: number;
+    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>;
+}
+
+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;
+}
+
+export { Namecheap as default };