domainstat 1.0.9 → 1.1.0

package/dist/adapters/altStatusAdapter.d.ts

@@ -0,0 +1,12 @@
+import { AdapterResponse, ParsedDomain } from '../types';
+import { BaseCheckerAdapter } from './baseAdapter';
+export declare class AltStatusAdapter extends BaseCheckerAdapter {
+    private domainrKey?;
+    constructor(domainrKey?: string);
+    private fetchDomainr;
+    private fetchMono;
+    protected doCheck(domainObj: ParsedDomain, opts?: {
+        signal?: AbortSignal;
+    }): Promise<AdapterResponse>;
+}
+//# sourceMappingURL=altStatusAdapter.d.ts.map

package/dist/adapters/baseAdapter.d.ts

@@ -0,0 +1,16 @@
+import { AdapterResponse, AdapterSource, CheckerAdapter, ParsedDomain, TldConfigEntry } from '../types';
+type BaseOpts = {
+    tldConfig?: TldConfigEntry;
+    signal?: AbortSignal;
+};
+export declare abstract class BaseCheckerAdapter implements CheckerAdapter {
+    readonly namespace: AdapterSource;
+    constructor(namespace: AdapterSource);
+    check(domainObj: ParsedDomain, opts?: BaseOpts): Promise<AdapterResponse>;
+    protected abstract doCheck(domainObj: ParsedDomain, opts?: {
+        tldConfig?: TldConfigEntry;
+        signal?: AbortSignal;
+    }): Promise<AdapterResponse>;
+}
+export {};
+//# sourceMappingURL=baseAdapter.d.ts.map

package/dist/adapters/dohAdapter.d.ts

@@ -0,0 +1,10 @@
+import { AdapterResponse, ParsedDomain } from '../types';
+import { BaseCheckerAdapter } from './baseAdapter';
+export declare class DohAdapter extends BaseCheckerAdapter {
+    private url;
+    constructor(url?: string);
+    protected doCheck(domainObj: ParsedDomain, opts?: {
+        signal?: AbortSignal;
+    }): Promise<AdapterResponse>;
+}
+//# sourceMappingURL=dohAdapter.d.ts.map

package/dist/adapters/rdapAdapter.d.ts

@@ -0,0 +1,11 @@
+import { AdapterResponse, ParsedDomain, TldConfigEntry } from '../types';
+import { BaseCheckerAdapter } from './baseAdapter';
+export declare class RdapAdapter extends BaseCheckerAdapter {
+    private baseUrl;
+    constructor(baseUrl?: string);
+    protected doCheck(domainObj: ParsedDomain, opts?: {
+        tldConfig?: TldConfigEntry;
+        signal?: AbortSignal;
+    }): Promise<AdapterResponse>;
+}
+//# sourceMappingURL=rdapAdapter.d.ts.map

package/dist/adapters/whoisApiAdapter.d.ts

@@ -0,0 +1,13 @@
+import { AdapterResponse, ParsedDomain } from '../types';
+import { BaseCheckerAdapter } from './baseAdapter';
+export declare class WhoisApiAdapter extends BaseCheckerAdapter {
+    private freaksKey?;
+    private xmlKey?;
+    constructor(freaksKey?: string, xmlKey?: string);
+    private fetchFreaks;
+    private fetchXml;
+    protected doCheck(domainObj: ParsedDomain, opts?: {
+        signal?: AbortSignal;
+    }): Promise<AdapterResponse>;
+}
+//# sourceMappingURL=whoisApiAdapter.d.ts.map

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { CheckOptions, DomainStatus } from "./types";
+export type { DomainStatus } from "./types";
+export declare function checkSerial(domain: string, opts?: CheckOptions): Promise<DomainStatus>;
+export declare function checkParallel(domain: string, opts?: CheckOptions): Promise<DomainStatus>;
+export declare function check(domain: string, opts?: CheckOptions): Promise<DomainStatus>;
+export declare function checkBatchStream(domains: string[], opts?: CheckOptions): AsyncGenerator<DomainStatus>;
+export declare function checkBatch(domains: string[], opts?: CheckOptions): Promise<DomainStatus[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/rdap-parser.d.ts

@@ -0,0 +1,74 @@
+type JCardProperty = [string, Record<string, any>, string, string | number];
+type JCard = ["vcard", JCardProperty[]];
+interface RdapLink {
+    value?: string;
+    rel?: string;
+    href?: string;
+    type?: string;
+}
+interface RdapEvent {
+    eventAction: string;
+    eventDate: string;
+}
+interface RdapPublicId {
+    type: string;
+    identifier: string;
+}
+interface RdapEntity {
+    objectClassName?: string;
+    handle?: string;
+    roles?: string[];
+    vcardArray?: JCard;
+    entities?: RdapEntity[];
+    publicIds?: RdapPublicId[];
+    links?: RdapLink[];
+}
+interface RdapNameserver {
+    ldhName?: string;
+}
+interface RdapData {
+    rdap?: RdapData;
+    ldhName?: string;
+    status?: string[];
+    events?: RdapEvent[];
+    entities?: RdapEntity[];
+    nameservers?: RdapNameserver[];
+    [key: string]: any;
+}
+type Whois = {
+    domainInfo: {
+        domainName: string;
+        registeredDate: string;
+        expiryDate: string;
+        lastUpdate: string;
+        status: string[];
+        nameservers?: string[] | undefined;
+    };
+    registrarInfo: {
+        registrar: string;
+        iana_id: string;
+        url: string;
+        abuseEmail: string;
+        abusePhone: string;
+    };
+    registrantInfo: {
+        fullName: string;
+        phone: string;
+        email: string;
+        address: {
+            street: string;
+            city: string;
+            zipcode: string;
+            country: string;
+            state?: string | undefined;
+        };
+    };
+    rawWhoisText?: string | undefined;
+    rawWhoisJson?: any;
+};
+/**
+ * Parses RDAP JSON data to match the WhoisSchema.
+ */
+export declare function parseRdapToWhois(rdapResponse: RdapData): Whois;
+export {};
+//# sourceMappingURL=rdap-parser.d.ts.map

package/dist/tldAdapters/index.d.ts

@@ -0,0 +1,9 @@
+import { CheckerAdapter } from '../types';
+export interface TldAdapter {
+    dns?: CheckerAdapter;
+    rdap?: CheckerAdapter;
+    whois?: CheckerAdapter;
+}
+export declare const tldAdapters: Record<string, TldAdapter>;
+export declare function getTldAdapter(suffix?: string): TldAdapter | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/tldAdapters/ngAdapter.d.ts

@@ -0,0 +1,11 @@
+import { BaseCheckerAdapter } from '../adapters/baseAdapter';
+import { AdapterResponse, AdapterSource, ParsedDomain } from '../types';
+export declare class NgAdapter extends BaseCheckerAdapter {
+    private source;
+    constructor(source: AdapterSource, namespace: AdapterSource);
+    private query;
+    protected doCheck(domainObj: ParsedDomain, opts?: {
+        signal?: AbortSignal;
+    }): Promise<AdapterResponse>;
+}
+//# sourceMappingURL=ngAdapter.d.ts.map

package/dist/types.d.ts

@@ -0,0 +1,87 @@
+import type { IResult } from 'tldts-core';
+export type Availability = 'unregistered' | 'registered' | 'unsupported' | 'invalid' | 'unknown';
+export type AdapterSource = 'validator' | 'dns.doh' | 'rdap' | 'rdap.ng' | 'altstatus' | 'altstatus.domainr' | 'altstatus.mono' | 'whois.api' | 'app';
+export interface AdapterError {
+    code: string;
+    message: string;
+    retryable: boolean;
+}
+export interface AdapterResponse {
+    domain: string;
+    availability: Availability;
+    fineStatus?: 'expiring_soon' | 'registered_not_in_use' | 'premium' | 'for_sale' | 'reserved';
+    source: AdapterSource;
+    raw: any;
+    /**
+     * Time taken for the adapter to produce this response in milliseconds.
+     */
+    latency?: number;
+    error?: AdapterError;
+}
+export interface DomainStatus {
+    domain: string;
+    availability: Availability;
+    fineStatus?: 'expiring_soon' | 'registered_not_in_use' | 'premium' | 'for_sale' | 'reserved';
+    resolver: AdapterSource;
+    /**
+     * Raw responses from each adapter keyed by its namespace.
+     */
+    raw: Record<string, any>;
+    /**
+     * Parsed responses from each adapter keyed by its namespace.
+     */
+    parsed: Record<string, any>;
+    /**
+     * Latency (in ms) reported by each adapter keyed by its namespace.
+     */
+    latencies: Record<string, number>;
+    error?: AdapterError;
+}
+export type ParsedDomain = IResult;
+export interface CheckerAdapter {
+    /** Unique identifier used to store results for this adapter */
+    namespace: string;
+    check(domainObj: ParsedDomain, opts?: {
+        tldConfig?: TldConfigEntry;
+        signal?: AbortSignal;
+    }): Promise<AdapterResponse>;
+}
+export interface TldConfigEntry {
+    rdapServer?: string;
+    skipRdap?: boolean;
+}
+export interface CheckOptions {
+    logger?: Console;
+    verbose?: boolean;
+    concurrency?: number;
+    /** Only run adapters whose namespace starts with one of these prefixes */
+    only?: string[];
+    /** Skip adapters whose namespace starts with one of these prefixes */
+    skip?: string[];
+    tldConfig?: TldConfigEntry;
+    /**
+     * Enable or disable caching. Caching is enabled by default.
+     */
+    cache?: boolean;
+    /**
+     * API keys for third-party services.
+     */
+    apiKeys?: {
+        domainr?: string;
+        whoisfreaks?: string;
+        whoisxml?: string;
+    };
+    /** When true, run adapters in parallel */
+    burstMode?: boolean;
+    /**
+     * Allotted latency before launching the next adapter in serial mode, keyed by adapter namespace.
+     * Defaults to 200ms when not specified for an adapter.
+     */
+    allottedLatency?: Partial<Record<AdapterSource, number>>;
+    /**
+     * Maximum execution time per adapter in milliseconds. When exceeded, the adapter is aborted.
+     * Provide values keyed by adapter namespace. If not specified, defaults may apply.
+     */
+    timeoutConfig?: Partial<Record<AdapterSource, number>>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/validator.d.ts

@@ -0,0 +1,3 @@
+import { DomainStatus, ParsedDomain } from './types.js';
+export declare function validateDomain(parsed: ParsedDomain, originalDomain: string): DomainStatus;
+//# sourceMappingURL=validator.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domainstat",
-  "version": "1.0.9",
+  "version": "1.1.0",
   "description": "Extremely fast domain status checker library using DoH, RDAP and WHOIS API.",
   "type": "module",
   "main": "./dist/index.js",
@@ -37,6 +37,9 @@
   "bin": {
     "domainstat": "./dist/cli.js"
   },
+  "files": [
+    "dist"
+  ],
   "license": "MIT",
   "dependencies": {
     "tldts": "^7.0.19"