@fraudnova/sdk 0.0.0-stage → 1.0.0

package/dist/index.cjs

@@ -0,0 +1,841 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AccountSuspendedError: () => AccountSuspendedError,
+  ApiError: () => ApiError,
+  AuthenticationError: () => AuthenticationError,
+  BATCH_MAX: () => BATCH_MAX,
+  BatchItem: () => BatchItem,
+  BatchResult: () => BatchResult,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  EmailResult: () => EmailResult,
+  FraudNova: () => FraudNova,
+  FraudNovaError: () => FraudNovaError,
+  InsufficientCreditsError: () => InsufficientCreditsError,
+  InvalidArgumentError: () => InvalidArgumentError,
+  IpResult: () => IpResult,
+  PhoneResult: () => PhoneResult,
+  RateLimitError: () => RateLimitError,
+  RetryPolicy: () => RetryPolicy,
+  TransportError: () => TransportError,
+  UnexpectedResponseError: () => UnexpectedResponseError,
+  UpstreamError: () => UpstreamError,
+  VERSION: () => VERSION,
+  ValidationError: () => ValidationError,
+  maskApiKey: () => maskApiKey,
+  parseDateInfo: () => parseDateInfo,
+  parseRetryAfter: () => parseRetryAfter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/version.ts
+var VERSION = "1.0.0";
+
+// src/errors.ts
+function maskApiKey(apiKey) {
+  return apiKey.length > 12 ? `fn_\u2026${apiKey.slice(-4)}` : "fn_\u2026";
+}
+var FraudNovaError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "FraudNovaError";
+  }
+};
+var InvalidArgumentError = class extends FraudNovaError {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidArgumentError";
+  }
+};
+var TransportError = class extends FraudNovaError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TransportError";
+  }
+};
+var ApiError = class _ApiError extends FraudNovaError {
+  statusCode;
+  apiMessage;
+  body;
+  constructor(statusCode, apiMessage, body = {}, message) {
+    super(message ?? `FraudNova API error (HTTP ${statusCode}): ${apiMessage}`);
+    this.name = "ApiError";
+    this.statusCode = statusCode;
+    this.apiMessage = apiMessage;
+    this.body = body;
+  }
+  static fromResponse(statusCode, text, retryAfter = null) {
+    let decoded = null;
+    try {
+      decoded = JSON.parse(text);
+    } catch {
+      decoded = null;
+    }
+    const isJson = typeof decoded === "object" && decoded !== null && !Array.isArray(decoded);
+    const body = isJson ? decoded : {};
+    const envelope = isJson && ("success" in body || "message" in body);
+    let apiMessage = "";
+    for (const key of ["message", "error"]) {
+      const value = body[key];
+      if (typeof value === "string" && value !== "") {
+        apiMessage = value;
+        break;
+      }
+    }
+    if (apiMessage === "") {
+      const stripped = text.trim();
+      apiMessage = stripped !== "" ? stripped.slice(0, 200) : `HTTP ${statusCode}`;
+    }
+    const full = isJson ? void 0 : `FraudNova API error (HTTP ${statusCode}): non-JSON response`;
+    if (envelope && statusCode === 401)
+      return new AuthenticationError(statusCode, apiMessage, body, full);
+    if (envelope && statusCode === 402) {
+      return new InsufficientCreditsError(statusCode, apiMessage, body, full);
+    }
+    if (envelope && statusCode === 403)
+      return new AccountSuspendedError(statusCode, apiMessage, body, full);
+    if (envelope && statusCode === 422)
+      return new ValidationError(statusCode, apiMessage, body, full);
+    if (statusCode === 429) {
+      return new RateLimitError(statusCode, apiMessage, body, retryAfter, full);
+    }
+    if (statusCode === 502 || statusCode === 503 || statusCode === 504) {
+      return new UpstreamError(statusCode, apiMessage, body, statusCode === 503 && envelope, full);
+    }
+    return new _ApiError(statusCode, apiMessage, body, full);
+  }
+};
+var AuthenticationError = class extends ApiError {
+  constructor(statusCode, apiMessage, body = {}, message) {
+    super(statusCode, apiMessage, body, message);
+    this.name = "AuthenticationError";
+  }
+};
+var InsufficientCreditsError = class extends ApiError {
+  constructor(statusCode, apiMessage, body = {}, message) {
+    super(statusCode, apiMessage, body, message);
+    this.name = "InsufficientCreditsError";
+  }
+};
+var AccountSuspendedError = class extends ApiError {
+  constructor(statusCode, apiMessage, body = {}, message) {
+    super(statusCode, apiMessage, body, message);
+    this.name = "AccountSuspendedError";
+  }
+};
+var ValidationError = class extends ApiError {
+  constructor(statusCode, apiMessage, body = {}, message) {
+    super(statusCode, apiMessage, body, message);
+    this.name = "ValidationError";
+  }
+};
+var RateLimitError = class extends ApiError {
+  retryAfter;
+  constructor(statusCode, apiMessage, body = {}, retryAfter = null, message) {
+    super(statusCode, apiMessage, body, message);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+  get isConcurrencyLimit() {
+    return this.apiMessage.includes("Too many concurrent requests");
+  }
+};
+var UpstreamError = class extends ApiError {
+  creditRefunded;
+  constructor(statusCode, apiMessage, body = {}, creditRefunded = false, message) {
+    let text = message ?? `FraudNova API error (HTTP ${statusCode}): ${apiMessage}`;
+    if (creditRefunded) text += " The credit for this check was refunded.";
+    super(statusCode, apiMessage, body, text);
+    this.name = "UpstreamError";
+    this.creditRefunded = creditRefunded;
+  }
+};
+var UnexpectedResponseError = class extends ApiError {
+  constructor(statusCode, apiMessage, body = {}, message) {
+    super(statusCode, apiMessage, body, message);
+    this.name = "UnexpectedResponseError";
+  }
+};
+
+// src/results.ts
+function coerceBool(v) {
+  return typeof v === "boolean" ? v : null;
+}
+function coerceString(v) {
+  return typeof v === "string" ? v : null;
+}
+function roundHalfAway(n) {
+  const r = Math.sign(n) * Math.floor(Math.abs(n) + 0.5);
+  return r === 0 ? 0 : r;
+}
+function coerceInt(v) {
+  let n;
+  if (typeof v === "number") {
+    n = v;
+  } else if (typeof v === "string" && (/^-?\d+$/.test(v) || /^-?\d+\.\d+$/.test(v))) {
+    n = Number(v);
+  } else {
+    return null;
+  }
+  return Number.isFinite(n) ? roundHalfAway(n) : null;
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function parseDateInfo(value) {
+  if (typeof value === "string") {
+    return { human: value, timestamp: null, iso: null };
+  }
+  if (isPlainObject(value)) {
+    return {
+      human: coerceString(value.human),
+      timestamp: coerceInt(value.timestamp),
+      iso: coerceString(value.iso)
+    };
+  }
+  return null;
+}
+var FlaggableResult = class {
+  creditsRemaining;
+  raw;
+  constructor(raw, creditsRemaining) {
+    this.raw = raw;
+    this.creditsRemaining = creditsRemaining;
+  }
+  toJSON() {
+    return this.raw;
+  }
+  flagReasons(options = {}) {
+    const threshold = options.riskThreshold ?? 75;
+    const reasons = [];
+    if ((coerceInt(this.raw.fraud_score) ?? 0) >= threshold) {
+      reasons.push("fraud_score");
+    }
+    for (const name of options.flagOn ?? this.defaultFlagOn()) {
+      if (this.raw[name] === true) {
+        reasons.push(name);
+      }
+    }
+    return reasons;
+  }
+  flagged(options = {}) {
+    return this.flagReasons(options).length > 0;
+  }
+};
+var IpResult = class _IpResult extends FlaggableResult {
+  static DEFAULT_FLAG_ON = ["proxy", "vpn", "tor"];
+  fraudScore;
+  proxy;
+  vpn;
+  tor;
+  activeVpn;
+  activeTor;
+  recentAbuse;
+  botStatus;
+  countryCode;
+  region;
+  city;
+  isp;
+  organization;
+  asn;
+  operatingSystem;
+  browser;
+  deviceBrand;
+  deviceModel;
+  constructor(raw, creditsRemaining) {
+    super(raw, creditsRemaining);
+    this.fraudScore = coerceInt(raw.fraud_score) ?? 0;
+    this.proxy = coerceBool(raw.proxy);
+    this.vpn = coerceBool(raw.vpn);
+    this.tor = coerceBool(raw.tor);
+    this.activeVpn = coerceBool(raw.active_vpn);
+    this.activeTor = coerceBool(raw.active_tor);
+    this.recentAbuse = coerceBool(raw.recent_abuse);
+    this.botStatus = coerceBool(raw.bot_status);
+    this.countryCode = coerceString(raw.country_code);
+    this.region = coerceString(raw.region);
+    this.city = coerceString(raw.city);
+    this.isp = coerceString(raw.ISP);
+    this.organization = coerceString(raw.organization);
+    this.asn = coerceInt(raw.ASN);
+    this.operatingSystem = coerceString(raw.operating_system);
+    this.browser = coerceString(raw.browser);
+    this.deviceBrand = coerceString(raw.device_brand);
+    this.deviceModel = coerceString(raw.device_model);
+  }
+  static fromData(data2, creditsRemaining = null) {
+    return new _IpResult(data2, creditsRemaining);
+  }
+  defaultFlagOn() {
+    return _IpResult.DEFAULT_FLAG_ON;
+  }
+};
+var EmailResult = class _EmailResult extends FlaggableResult {
+  static DEFAULT_FLAG_ON = ["disposable"];
+  fraudScore;
+  valid;
+  disposable;
+  catchAll;
+  generic;
+  common;
+  dnsValid;
+  honeypot;
+  frequentComplainer;
+  suspect;
+  recentAbuse;
+  leaked;
+  riskyTld;
+  spfRecord;
+  dmarcRecord;
+  smtpScore;
+  overallScore;
+  deliverability;
+  spamTrapScore;
+  resultType;
+  sanitizedEmail;
+  firstSeen;
+  domainAge;
+  constructor(raw, creditsRemaining) {
+    super(raw, creditsRemaining);
+    this.fraudScore = coerceInt(raw.fraud_score) ?? 0;
+    this.valid = coerceBool(raw.valid);
+    this.disposable = coerceBool(raw.disposable);
+    this.catchAll = coerceBool(raw.catch_all);
+    this.generic = coerceBool(raw.generic);
+    this.common = coerceBool(raw.common);
+    this.dnsValid = coerceBool(raw.dns_valid);
+    this.honeypot = coerceBool(raw.honeypot);
+    this.frequentComplainer = coerceBool(raw.frequent_complainer);
+    this.suspect = coerceBool(raw.suspect);
+    this.recentAbuse = coerceBool(raw.recent_abuse);
+    this.leaked = coerceBool(raw.leaked);
+    this.riskyTld = coerceBool(raw.risky_tld);
+    this.spfRecord = coerceBool(raw.spf_record);
+    this.dmarcRecord = coerceBool(raw.dmarc_record);
+    this.smtpScore = coerceInt(raw.smtp_score);
+    this.overallScore = coerceInt(raw.overall_score);
+    this.deliverability = coerceString(raw.deliverability);
+    this.spamTrapScore = coerceString(raw.spam_trap_score);
+    this.resultType = coerceString(raw.result_type);
+    this.sanitizedEmail = coerceString(raw.sanitized_email);
+    this.firstSeen = parseDateInfo(raw.first_seen);
+    this.domainAge = parseDateInfo(raw.domain_age);
+  }
+  static fromData(data2, creditsRemaining = null) {
+    return new _EmailResult(data2, creditsRemaining);
+  }
+  defaultFlagOn() {
+    return _EmailResult.DEFAULT_FLAG_ON;
+  }
+};
+var PhoneResult = class _PhoneResult extends FlaggableResult {
+  static DEFAULT_FLAG_ON = ["VOIP", "risky"];
+  fraudScore;
+  valid;
+  recentAbuse;
+  voip;
+  prepaid;
+  risky;
+  active;
+  doNotCall;
+  leaked;
+  spammer;
+  dialingCode;
+  carrier;
+  lineType;
+  country;
+  region;
+  city;
+  timezone;
+  zipCode;
+  activeStatus;
+  formatted;
+  localFormat;
+  constructor(raw, creditsRemaining) {
+    super(raw, creditsRemaining);
+    this.fraudScore = coerceInt(raw.fraud_score) ?? 0;
+    this.valid = coerceBool(raw.valid);
+    this.recentAbuse = coerceBool(raw.recent_abuse);
+    this.voip = coerceBool(raw.VOIP);
+    this.prepaid = coerceBool(raw.prepaid);
+    this.risky = coerceBool(raw.risky);
+    this.active = coerceBool(raw.active);
+    this.doNotCall = coerceBool(raw.do_not_call);
+    this.leaked = coerceBool(raw.leaked);
+    this.spammer = coerceBool(raw.spammer);
+    this.dialingCode = coerceInt(raw.dialing_code);
+    this.carrier = coerceString(raw.carrier);
+    this.lineType = coerceString(raw.line_type);
+    this.country = coerceString(raw.country);
+    this.region = coerceString(raw.region);
+    this.city = coerceString(raw.city);
+    this.timezone = coerceString(raw.timezone);
+    this.zipCode = coerceString(raw.zip_code);
+    this.activeStatus = coerceString(raw.active_status);
+    this.formatted = coerceString(raw.formatted);
+    this.localFormat = coerceString(raw.local_format);
+  }
+  static fromData(data2, creditsRemaining = null) {
+    return new _PhoneResult(data2, creditsRemaining);
+  }
+  defaultFlagOn() {
+    return _PhoneResult.DEFAULT_FLAG_ON;
+  }
+};
+var BatchItem = class {
+  constructor(subject2, success, result, error) {
+    this.subject = subject2;
+    this.success = success;
+    this.result = result;
+    this.error = error;
+  }
+  subject;
+  success;
+  result;
+  error;
+  isInvalid() {
+    return this.error === "invalid_ip" || this.error === "invalid_email" || this.error === "invalid_phone";
+  }
+  isInsufficientCredits() {
+    return this.error === "insufficient_credits";
+  }
+  isUpstreamFailed() {
+    return this.error === "upstream_failed";
+  }
+};
+var BatchResult = class _BatchResult {
+  constructor(items, creditsRemaining) {
+    this.items = items;
+    this.creditsRemaining = creditsRemaining;
+  }
+  items;
+  creditsRemaining;
+  static fromEnvelope(envelope, kind) {
+    const items = [];
+    const rawItems = envelope.results;
+    if (Array.isArray(rawItems)) {
+      for (const item of rawItems) {
+        if (!isPlainObject(item)) {
+          continue;
+        }
+        const success = coerceBool(item.success) ?? false;
+        const data2 = item.data;
+        let result = null;
+        if (success && isPlainObject(data2)) {
+          result = kind === "ip" ? IpResult.fromData(data2) : kind === "email" ? EmailResult.fromData(data2) : PhoneResult.fromData(data2);
+        }
+        items.push(
+          new BatchItem(coerceString(item[kind]) ?? "", success, result, coerceString(item.error))
+        );
+      }
+    }
+    return new _BatchResult(items, coerceInt(envelope.credits_remaining) ?? 0);
+  }
+  successful() {
+    return this.items.filter((i) => i.success);
+  }
+  failed() {
+    return this.items.filter((i) => !i.success);
+  }
+  hasFailures() {
+    return this.items.some((i) => !i.success);
+  }
+  get length() {
+    return this.items.length;
+  }
+  *[Symbol.iterator]() {
+    yield* this.items;
+  }
+};
+
+// src/retry.ts
+function parseRetryAfter(value, now = /* @__PURE__ */ new Date()) {
+  if (value === null) return null;
+  const text = value.trim();
+  if (text === "") return null;
+  if (/^[0-9]+$/.test(text)) return Number.parseInt(text, 10);
+  const when = Date.parse(text);
+  if (Number.isNaN(when)) return null;
+  return Math.max(0, Math.ceil((when - now.getTime()) / 1e3));
+}
+var defaultSleep = (seconds) => new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+var RetryPolicy = class {
+  maxAttempts;
+  concurrencyDelays;
+  rateLimitDelays;
+  honourRetryAfter;
+  maxRetryAfter;
+  #sleeper;
+  constructor(options = {}) {
+    this.maxAttempts = options.maxAttempts ?? 3;
+    this.concurrencyDelays = [...options.concurrencyDelays ?? [1, 2, 4]];
+    this.rateLimitDelays = [...options.rateLimitDelays ?? [5, 15, 40]];
+    this.honourRetryAfter = options.honourRetryAfter ?? true;
+    this.maxRetryAfter = options.maxRetryAfter ?? 60;
+    this.#sleeper = options.sleep ?? defaultSleep;
+    if (!Number.isInteger(this.maxAttempts) || this.maxAttempts < 1) {
+      throw new InvalidArgumentError("maxAttempts must be an integer of at least 1.");
+    }
+    if (!Number.isFinite(this.maxRetryAfter) || this.maxRetryAfter < 0) {
+      throw new InvalidArgumentError("maxRetryAfter must be a finite number that is not negative.");
+    }
+    for (const [name, delays] of [
+      ["concurrencyDelays", this.concurrencyDelays],
+      ["rateLimitDelays", this.rateLimitDelays]
+    ]) {
+      if (!delays.every((delay) => typeof delay === "number" && Number.isFinite(delay) && delay >= 0)) {
+        throw new InvalidArgumentError(
+          `${name} must contain only finite numbers that are not negative.`
+        );
+      }
+    }
+  }
+  /** Seconds to wait before retrying after `attempt` (1-based) failed, or null to stop. */
+  delayFor(error, attempt) {
+    if (attempt >= this.maxAttempts) return null;
+    if (this.honourRetryAfter && error.retryAfter !== null) {
+      return error.retryAfter > this.maxRetryAfter ? null : error.retryAfter;
+    }
+    const schedule = error.isConcurrencyLimit ? this.concurrencyDelays : this.rateLimitDelays;
+    const delay = schedule[attempt - 1];
+    return delay === void 0 ? null : delay;
+  }
+  sleep(seconds) {
+    return this.#sleeper(seconds);
+  }
+};
+
+// src/transport.ts
+function userAgent() {
+  let agent = `fraudnova-node/${VERSION}`;
+  if (typeof process !== "undefined" && typeof process.versions?.node === "string") {
+    agent += ` node/${process.versions.node}`;
+  }
+  return agent;
+}
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var Transport = class _Transport {
+  baseUrl;
+  #apiKey;
+  #timeout;
+  #retry;
+  #fetch;
+  #userAgent;
+  constructor(options) {
+    if (!/^[\x21-\x7e]+$/.test(options.apiKey)) {
+      throw new InvalidArgumentError(
+        "apiKey must contain only printable ASCII characters, without whitespace."
+      );
+    }
+    let fetchImpl = options.fetch ?? null;
+    if (fetchImpl === null) {
+      const globalFetch = globalThis.fetch;
+      if (typeof globalFetch === "function") {
+        fetchImpl = globalFetch.bind(globalThis);
+      }
+    }
+    if (fetchImpl === null) {
+      throw new InvalidArgumentError(
+        "No fetch implementation available; pass one in the fetch option"
+      );
+    }
+    this.#apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.#timeout = options.timeout;
+    this.#retry = options.retry;
+    this.#fetch = fetchImpl;
+    this.#userAgent = userAgent();
+  }
+  get(path, params = null, authenticated = true) {
+    const query = new URLSearchParams();
+    for (const [name, value] of Object.entries(params ?? {})) {
+      if (value === void 0 || value === null) continue;
+      query.append(name, String(value));
+    }
+    const search = query.toString();
+    const url = this.baseUrl + path + (search !== "" ? `?${search}` : "");
+    return this.#send("GET", url, authenticated);
+  }
+  post(path, json) {
+    return this.#send("POST", this.baseUrl + path, true, JSON.stringify(json));
+  }
+  #headers(authenticated, hasBody) {
+    const headers = {
+      Accept: "application/json",
+      "User-Agent": this.#userAgent
+    };
+    if (authenticated) headers.Authorization = `Bearer ${this.#apiKey}`;
+    if (hasBody) headers["Content-Type"] = "application/json";
+    return headers;
+  }
+  async #send(method, url, authenticated, body) {
+    let attempt = 1;
+    for (; ; ) {
+      const init = {
+        method,
+        headers: this.#headers(authenticated, body !== void 0)
+      };
+      if (body !== void 0) init.body = body;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.#timeout);
+      let response;
+      let text;
+      try {
+        response = await this.#fetch(url, { ...init, signal: controller.signal });
+        text = await response.text();
+      } catch (error) {
+        if (controller.signal.aborted) {
+          throw new TransportError(`FraudNova request timed out after ${this.#timeout} ms`, {
+            cause: error
+          });
+        }
+        const original = error instanceof Error ? error.message : String(error);
+        const masked = original.split(this.#apiKey).join(maskApiKey(this.#apiKey));
+        throw new TransportError(`FraudNova request failed: ${masked}`, { cause: error });
+      } finally {
+        clearTimeout(timer);
+      }
+      try {
+        return _Transport.#decode(response, text);
+      } catch (error) {
+        if (!(error instanceof RateLimitError)) throw error;
+        const delay = this.#retry?.delayFor(error, attempt) ?? null;
+        if (this.#retry === null || delay === null) throw error;
+        await this.#retry.sleep(delay);
+        attempt++;
+      }
+    }
+  }
+  static #decode(response, text) {
+    const status = response.status;
+    if (status < 200 || status >= 300) {
+      throw ApiError.fromResponse(
+        status,
+        text,
+        parseRetryAfter(response.headers.get("retry-after"))
+      );
+    }
+    let decoded = null;
+    try {
+      decoded = JSON.parse(text);
+    } catch {
+      decoded = null;
+    }
+    if (!isPlainObject2(decoded) || decoded.success !== true) {
+      throw new UnexpectedResponseError(
+        status,
+        "Unexpected response body",
+        isPlainObject2(decoded) ? decoded : {}
+      );
+    }
+    return decoded;
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://fraudnova.com/api/v1";
+var BATCH_MAX = 100;
+var DEFAULT_TIMEOUT = 3e4;
+var inspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+function subject(value, name) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new InvalidArgumentError(`${name} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function strictness(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 3) {
+    throw new InvalidArgumentError("strictness must be an integer from 0 to 3");
+  }
+  return value;
+}
+function country(value) {
+  if (typeof value !== "string") return void 0;
+  const cleaned = value.trim().toUpperCase();
+  return cleaned !== "" ? cleaned : void 0;
+}
+function data(envelope) {
+  const value = envelope.data;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new UnexpectedResponseError(200, "Missing data", envelope);
+  }
+  return value;
+}
+function ipOptions(options) {
+  const out = {};
+  const level = strictness(options.strictness);
+  if (level !== void 0) out.strictness = level;
+  if (options.mobile === true || options.mobile === false) out.mobile = options.mobile;
+  if (options.userAgent !== void 0) out.user_agent = options.userAgent;
+  if (options.userLanguage !== void 0) out.user_language = options.userLanguage;
+  return out;
+}
+var FraudNova = class {
+  baseUrl;
+  #apiKey;
+  #transport;
+  constructor(apiKey, options = {}) {
+    if (typeof apiKey !== "string" || apiKey.trim() === "") {
+      throw new InvalidArgumentError("apiKey must be a non-empty string");
+    }
+    const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    if (typeof baseUrl !== "string" || !/^https?:\/\//i.test(baseUrl)) {
+      throw new InvalidArgumentError("baseUrl must start with http:// or https://");
+    }
+    const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    if (typeof timeout !== "number" || !Number.isFinite(timeout) || timeout <= 0 || timeout > 2147483647) {
+      throw new InvalidArgumentError(
+        "timeout must be a positive number of milliseconds (at most 2147483647)"
+      );
+    }
+    this.#apiKey = apiKey.trim();
+    this.#transport = new Transport({
+      apiKey: this.#apiKey,
+      baseUrl,
+      timeout,
+      retry: options.retry ?? null,
+      fetch: options.fetch ?? null
+    });
+    this.baseUrl = this.#transport.baseUrl;
+  }
+  /** Score one IP address. */
+  async checkIp(ip, options = {}) {
+    const params = { ip: subject(ip, "ip"), ...ipOptions(options) };
+    const envelope = await this.#transport.get("/check", params);
+    return IpResult.fromData(data(envelope), coerceInt(envelope.credits_remaining));
+  }
+  /** Score one email address. */
+  async checkEmail(email) {
+    const params = { email: subject(email, "email") };
+    const envelope = await this.#transport.get("/check/email", params);
+    return EmailResult.fromData(data(envelope), coerceInt(envelope.credits_remaining));
+  }
+  /** Score one phone number. */
+  async checkPhone(phone, options = {}) {
+    const params = { phone: subject(phone, "phone"), country: country(options.country) };
+    const envelope = await this.#transport.get("/check/phone", params);
+    return PhoneResult.fromData(data(envelope), coerceInt(envelope.credits_remaining));
+  }
+  /** Score many IP addresses, chunked by {@link BATCH_MAX}. */
+  async checkIps(ips, options = {}) {
+    return this.#batch("/check/batch", "ips", "ip", ips, ipOptions(options));
+  }
+  /** Score many email addresses, chunked by {@link BATCH_MAX}. */
+  async checkEmails(emails) {
+    return this.#batch("/check/email/batch", "emails", "email", emails, {});
+  }
+  /** Score many phone numbers, chunked by {@link BATCH_MAX}. */
+  async checkPhones(phones, options = {}) {
+    const code = country(options.country);
+    const extra = code !== void 0 ? { country: code } : {};
+    return this.#batch("/check/phone/batch", "phones", "phone", phones, extra);
+  }
+  /** The account's remaining credits. */
+  async balance() {
+    const envelope = await this.#transport.get("/balance");
+    const credits = coerceInt(envelope.credits_remaining);
+    if (credits === null) {
+      throw new UnexpectedResponseError(200, "Missing credits_remaining", envelope);
+    }
+    return credits;
+  }
+  /** The caller's public IP address as the API sees it (free, unauthenticated). */
+  async myIp() {
+    const envelope = await this.#transport.get("/my-ip", null, false);
+    const ip = envelope.ip;
+    if (typeof ip !== "string" || ip === "") {
+      throw new UnexpectedResponseError(200, "Missing ip", envelope);
+    }
+    return ip;
+  }
+  async #batch(path, field, kind, subjects, extra) {
+    if (!Array.isArray(subjects)) {
+      throw new InvalidArgumentError(`${field} must be an array of values`);
+    }
+    if (subjects.length === 0) {
+      throw new InvalidArgumentError(`${field} must not be empty`);
+    }
+    const cleaned = subjects.map((item, index) => {
+      if (item !== null && typeof item !== "string") {
+        throw new InvalidArgumentError(`${field}[${index}] must be a string or null`);
+      }
+      return item === null ? null : item.trim();
+    });
+    const items = [];
+    let credits = 0;
+    for (let start = 0; start < cleaned.length; start += BATCH_MAX) {
+      const chunk = cleaned.slice(start, start + BATCH_MAX);
+      const envelope = await this.#transport.post(path, { [field]: chunk, ...extra });
+      if (!Array.isArray(envelope.results)) {
+        throw new UnexpectedResponseError(200, "Missing results", envelope);
+      }
+      const part = BatchResult.fromEnvelope(envelope, kind);
+      items.push(...part.items);
+      credits = part.creditsRemaining;
+      const rest = cleaned.slice(start + BATCH_MAX);
+      if (rest.length > 0 && coerceInt(envelope.credits_remaining) === 0) {
+        for (const item of rest) {
+          items.push(new BatchItem(item ?? "", false, null, "insufficient_credits"));
+        }
+        break;
+      }
+    }
+    return new BatchResult(items, credits);
+  }
+  toString() {
+    return `FraudNova { apiKey: "${maskApiKey(this.#apiKey)}", baseUrl: "${this.baseUrl}" }`;
+  }
+  [inspectSymbol]() {
+    return this.toString();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccountSuspendedError,
+  ApiError,
+  AuthenticationError,
+  BATCH_MAX,
+  BatchItem,
+  BatchResult,
+  DEFAULT_BASE_URL,
+  EmailResult,
+  FraudNova,
+  FraudNovaError,
+  InsufficientCreditsError,
+  InvalidArgumentError,
+  IpResult,
+  PhoneResult,
+  RateLimitError,
+  RetryPolicy,
+  TransportError,
+  UnexpectedResponseError,
+  UpstreamError,
+  VERSION,
+  ValidationError,
+  maskApiKey,
+  parseDateInfo,
+  parseRetryAfter
+});
+//# sourceMappingURL=index.cjs.map