@ix-xs/node-comfort 1.1.31 → 2.0.0

package/types/index.d.ts

@@ -1,120 +1,693 @@
-declare const _exports: {
-    SQLite: {
-        new (path?: string): SQLite;
-    };
-    wait(ms: number): Promise<void>;
-    when(predicate: boolean | Promise<boolean> | (() => boolean | Promise<boolean>), payload?: any, options?: {
-        interval?: number | undefined;
-        timeout?: number | null | undefined;
-        max?: number | null | undefined;
-    }): {
-        start: () => any;
-        stop: () => any;
-        on: <E extends "error" | "trigger" | "timeout">(event: E, handler: E extends "error" ? (error: unknown) => void | Promise<void> : (payload: any) => void | Promise<void>) => any;
-    };
-    dontCrash(): {
-        on: <E extends "error" | "exit" | "sig" | "beforeExit">(event: E, handler?: (E extends "error" ? (error: Error | unknown) => void | Promise<void> : E extends "exit" ? (code: number) => void | Promise<void> : E extends "sig" ? (signal: "SIGINT" | "SIGTERM" | "SIGQUIT") => void | Promise<void> : (code: number) => void | Promise<void>)) => any;
-    };
-    JSONString(value: any): string;
-    JSONParse(value: string): any;
-    isArray(value: any): boolean;
-    isNumber(value: any): boolean;
-    isFunction(value: any): boolean;
-    isObject(value: any): boolean;
-    isBoolean(value: any): boolean;
-    isString(value: any): boolean;
-    isUndefined(value: any): boolean;
-    isNull(value: any): boolean;
-    isDate(value: any): boolean;
-    isMap(value: any): boolean;
-    isSet(value: any): boolean;
-    isError(value: any): boolean;
-    getEnv(value: string, envFilePath?: string): string | undefined;
-    createPath(path?: string): string;
-    getFoldersIn(path?: string, recursive?: boolean): string[] | undefined;
-    getFolder(path?: string): string | undefined;
-    getFilesIn(path?: string, recursive?: boolean): string[] | undefined;
-    getFile(path: string): string | undefined;
-    createFolder(path: string, force?: boolean): boolean | undefined;
-    createFile(path: string, force?: boolean, data?: string | object | null | undefined): boolean | undefined;
-    deleteFoldersIn(path?: string, filter?: (folder: string) => boolean): number | undefined;
-    deleteFolder(path: string): boolean | undefined;
-    deleteFilesIn(path?: string, recursive?: boolean, filter?: (file: string) => boolean): number | undefined;
-    deleteFile(path: string): boolean | undefined;
-    copyFoldersIn(options: {
-        dest: string;
-        path?: string | undefined;
-        recursive?: boolean | undefined;
-        withFiles?: boolean | undefined;
-        force?: boolean | undefined;
-        filter?: ((folder: string) => boolean) | undefined;
-    }): number | undefined;
-    copyFolder(options: {
-        dest: string;
-        path?: string | undefined;
-        recursive?: boolean | undefined;
-        withFiles?: boolean | undefined;
-        force?: boolean | undefined;
-    }): boolean | undefined;
-    copyFilesIn(options: {
-        dest: string;
-        path?: string | undefined;
-        recursive?: boolean | undefined;
-        force?: boolean | undefined;
-        filter?: ((file: string) => boolean) | undefined;
-    }): number | undefined;
-    copyFile(options: {
-        path: string;
-        dest: string;
-        force?: boolean | undefined;
-    }): boolean | undefined;
-    moveFoldersIn(options: {
-        dest: string;
-        path?: string | undefined;
-        recursive?: boolean | undefined;
-        withFiles?: boolean | undefined;
-        force?: boolean | undefined;
-        filter?: ((folder: string) => boolean) | undefined;
-    }): number | undefined;
-    moveFolder(options: {
-        path: string;
-        dest: string;
-        recursive?: boolean | undefined;
-        withFiles?: boolean | undefined;
-        force?: boolean | undefined;
-    }): boolean | undefined;
-    moveFilesIn(options: {
-        dest: string;
-        path?: string | undefined;
-        recursive?: boolean | undefined;
-        force?: boolean | undefined;
-        filter?: ((file: string) => boolean) | undefined;
-    }): number | undefined;
-    moveFile(options: {
-        path: string;
-        dest: string;
-        force?: boolean | undefined;
-    }): boolean | undefined;
-    readFile(path: string): string | undefined;
-    watch(options?: {
-        path?: string | undefined;
-        recursive?: boolean | undefined;
-        filter?: ((event: "rename" | "change", file: string) => boolean) | undefined;
-    }): {
-        on: <E extends "change" | "rename" | "all">(event: E, callback: E extends "all" ? (event: "change" | "rename", file: string) => void | Promise<void> : (file: string) => void | Promise<void>) => any;
-        stop: () => void;
-        pause: () => any;
-        resume: () => any;
-    } | undefined;
-    setTimestamp(value: boolean): Logger;
-    setDelimiter(options?: {
-        open?: string | undefined;
-        close?: string | undefined;
-    }): Logger;
-    log(content: any): Logger;
-    group(label: string): Logger;
-    groupEnd(): Logger;
-};
-export = _exports;
-import SQLite = require("./src/SQLite");
-//# sourceMappingURL=index.d.ts.map
+// Generated by scripts/build-types.js. Do not edit by hand.
+// @ix-xs/node-comfort v2.0.0
+
+import _Arr = require("./src/Arr");
+import _Async = require("./src/Async");
+import _Cache = require("./src/Cache");
+import _Checker = require("./src/Checker");
+import _Cli = require("./src/Cli");
+import _Color = require("./src/Color");
+import _Crypto = require("./src/Crypto");
+import _Emitter = require("./src/Emitter");
+import _Env = require("./src/Env");
+import _errors = require("./src/errors");
+import _FS = require("./src/FS");
+import _Func = require("./src/Func");
+import _Http = require("./src/Http");
+import _Id = require("./src/Id");
+import _Logger = require("./src/Logger");
+import _Num = require("./src/Num");
+import _Obj = require("./src/Obj");
+import _Schema = require("./src/Schema");
+import _SQLite = require("./src/SQLite");
+import _Str = require("./src/Str");
+import _Sys = require("./src/Sys");
+import _Time = require("./src/Time");
+import _Utils = require("./src/Utils");
+
+/**
+ * **@ix-xs/node-comfort**: The zero-dependency standard library for Node.js: logger, filesystem, SQLite, schema validation, HTTP client, CLI toolkit, cache, env, async pools, colors, events, i18n dates, ids, crypto and hundreds of fully typed helpers.
+ *
+ * @example
+ * const nc = require("@ix-xs/node-comfort");
+ * nc.info("Server ready");
+ * nc.str.slugify("Héllo World"); // "hello-world"
+ *
+ * @example
+ * import { nc, slugify, isEmail } from "@ix-xs/node-comfort";
+ */
+declare namespace nodeComfort {
+
+  // Namespaces and classes
+  /**
+   * A console logger that works with zero setup: levels, colors, a small
+   * markup for styling, groups, timers and tables. In production, switch to
+   * one JSON object per line with `LOG_FORMAT=json`, and write to rotating
+   * files if you need to.
+   *
+   * Markup: `<% red bold Error:%> disk is full`. Any style name works, plus
+   * `#ff8800`, `bg#1e1e2e`, `rgb(255, 128, 0)` and `bgRgb(...)`.
+   *
+   * Levels, from chatty to severe: `trace`, `debug`, `info`, `warn`, `error`,
+   * `fatal`. The default is `info`, or `debug` when `DEBUG` is set; `LOG_LEVEL`
+   * overrides it. Warnings and errors go to stderr.
+   *
+   * @example
+   * nc.info("Server listening on port 3000");
+   * nc.warn("Cache is almost full");
+   * nc.error(new Error("Payment failed", { cause: err }));
+   * nc.log("<% cyan bold Tip:%> press <% bgWhite black  q  %> to quit");
+   */
+  export import logger = _Logger;
+  /**
+   * Files and folders without try/catch: read and write text or JSON
+   * (atomically), copy, move, delete, list, glob, watch, hash.
+   *
+   * Paths: absolute paths are used as they are. Paths starting with `./` or
+   * `../` start from the file that calls the function, so a script works
+   * wherever it's run from. Other relative paths start from the working
+   * directory, like Node's `fs`.
+   *
+   * Everyday failures don't throw: you get `undefined` when something doesn't
+   * exist and `false` when an operation fails.
+   *
+   * @example
+   * nc.writeJSON("./data/settings.json", { theme: "dark" });
+   * const settings = nc.readJSON("./data/settings.json", {});
+   * const sources = nc.glob("src/**\/*.{js,ts}");
+   */
+  export import fs = _FS;
+  /**
+   * Type checks and validators. Every `isX` accepts anything and never throws,
+   * and most of them are type guards: inside `if (nc.isString(value))`, your
+   * editor knows `value` is a string, in JavaScript too.
+   *
+   * @example
+   * if (nc.isEmail(body.email) && nc.isPort(body.port)) connect(body);
+   * nc.assert(user, "User not found");
+   */
+  export import checker = _Checker;
+  /**
+   * Everyday helpers: `wait`, `when`, `dontCrash`, and JSON functions that
+   * don't throw. They are also available at the top level (`nc.wait()`).
+   *
+   * @example
+   * await nc.wait("1.5s");
+   * const settings = nc.JSONParse(text, {});
+   */
+  export import utils = _Utils;
+  /**
+   * String helpers: case conversion, slugs, truncation, templates, wrapping,
+   * fuzzy matching, plurals. Nothing is mutated, any value is accepted, and
+   * lengths are counted the way you see them, so 👨‍👩‍👧 is one character and
+   * is never cut in half.
+   *
+   * @example
+   * str.slugify("Héllo, Wörld!");                    // "hello-world"
+   * str.camelCase("user_first-name");                // "userFirstName"
+   * str.plural(3, { one: "file", other: "files" }); // "3 files"
+   */
+  export import str = _Str;
+  /**
+   * Numbers: clamping, rounding that gets decimals right, statistics, and
+   * formatting for humans (sizes, money, ordinals, compact numbers) in any
+   * language. Formatting is English by default: change it with `setLocale()`
+   * or per call with `{ locale }`.
+   *
+   * @example
+   * num.round(1.005, 2);                           // 1.01
+   * num.formatBytes(1536);                         // "1.5 KB"
+   * num.currency(1234.5, "EUR", { locale: "fr" }); // "1 234,50 €"
+   * num.percentile(latencies, 95);
+   */
+  export import num = _Num;
+  /**
+   * Array helpers. None of them mutate what you pass in, and item types carry
+   * through (`chunk(numbers, 2)` is a `number[][]`). Many take an iteratee:
+   * a property name, which your editor completes, or a function.
+   *
+   * @example
+   * arr.chunk([1, 2, 3, 4, 5], 2);          // [[1, 2], [3, 4], [5]]
+   * arr.groupBy(users, "role");             // { admin: [...], user: [...] }
+   * arr.sortBy(users, ["lastName", "age"]);
+   */
+  export import arr = _Arr;
+  /**
+   * Object helpers: deep clone, merge, equality, diff, typed dot paths,
+   * pick and omit. Inputs are never mutated, and `__proto__`, `constructor`
+   * and `prototype` keys are always ignored, so user input can't pollute
+   * prototypes.
+   *
+   * @example
+   * obj.get(config, "db.pool.max", 10);         // typed, paths autocompleted
+   * obj.set(state, "user.profile.name", "Ada"); // returns an updated copy
+   * obj.merge(defaults, userConfig);
+   */
+  export import obj = _Obj;
+  /**
+   * Function helpers: debounce, throttle, memoize, retry with backoff,
+   * timeouts, error handling without try/catch, and typed composition.
+   *
+   * @example
+   * const save = func.debounce(persist, 300);
+   * const data = await func.retry(() => fetchJSON(url), { attempts: 5, delay: 200, backoff: 2 });
+   * const [error, user] = await func.to(getUser(id));
+   */
+  export import func = _Func;
+  /**
+   * Dates and durations: formatting, relative time, calendar math, time zones
+   * and scheduling, in any language `Intl` knows. The default language is
+   * English so results are the same on every machine; change it with
+   * `setLocale()` or per call with `{ locale }`. Time zones work the same way
+   * with `setTimezone()` or `{ timeZone }`.
+   *
+   * @example
+   * time.setLocale("fr").setTimezone("Europe/Paris");
+   * time.relative(Date.now() - 3600e3);        // "il y a 1 heure"
+   * time.format(new Date(), "dddd D MMMM YYYY"); // "lundi 15 janvier 2024"
+   * time.cron("0 9 * * 1-5", sendReport);        // weekdays at 9:00
+   */
+  export import time = _Time;
+  /**
+   * Unique ids: UUID v4 and v7, ULID, nanoid-style ids, Snowflakes, tokens
+   * and short codes. All of them use the secure random generator of
+   * `node:crypto`, with no bias.
+   *
+   * @example
+   * id.uuidv7();  // "0190a5c4-7c1e-7b2a-9f3e-1c2d3e4f5a6b", sorts by creation time
+   * id.nano();    // "V1StGXR8_Z5jdHi6B-myT"
+   * id.code();    // "K7QF9X"
+   * id.token(32); // for API keys and reset links
+   */
+  export import id = _Id;
+  /**
+   * Crypto without the footguns, built on `node:crypto`: hashes, HMAC,
+   * password hashing (scrypt), encryption (AES-256-GCM), JWT, two-factor
+   * codes (TOTP) and secure random values.
+   *
+   * @example
+   * const stored = await crypto.hashPassword("hunter2");
+   * await crypto.verifyPassword("hunter2", stored); // true
+   *
+   * const token = crypto.signJWT({ sub: user.id }, SECRET, { expiresIn: "1h" });
+   * const claims = crypto.verifyJWT(token, SECRET);
+   */
+  export import crypto = _Crypto;
+  /**
+   * Terminal colors you can chain, like `chalk`. Truecolor is supported and
+   * downgraded on older terminals. Colors switch off by themselves when the
+   * output isn't a terminal or `NO_COLOR` is set; `FORCE_COLOR=1|2|3` turns
+   * them back on.
+   *
+   * @example
+   * console.log(color.green.bold("✔ Done"), color.gray("in 1.2s"));
+   * console.log(color.bgHex("#1e1e2e").hex("#cba6f7")(" nc "));
+   * console.log(color.gradient("node-comfort", ["#ff5f6d", "#ffc371"]));
+   */
+  export import color = _Color;
+  /**
+   * What you need for command-line tools: typed arguments with a generated
+   * `--help`, prompts, arrow-key menus, spinners, progress bars, tables and
+   * boxes. When nobody's at the keyboard (CI, pipes), prompts read plain lines
+   * and animations print only their final state.
+   *
+   * @example
+   * const { flags } = cli.args({
+   *   port: { type: "number", short: "p", default: 3000, description: "Port to listen on" },
+   * });
+   * const name = await cli.prompt("Project name?", { default: "my-app" });
+   * const spin = cli.spinner("Installing").start();
+   * spin.succeed("Installed");
+   */
+  export import cli = _Cli;
+  /**
+   * Processes and the system: run commands and get their output, find
+   * executables, shut down cleanly, open URLs, and learn about the machine.
+   * Behaves the same on Windows, macOS and Linux; on Windows,
+   * `run("npm", [...])` finds `npm.cmd` and escapes arguments safely.
+   *
+   * @example
+   * const { stdout } = await sys.run("git", ["rev-parse", "HEAD"]);
+   * sys.onShutdown(async () => {
+   *   await server.close();
+   *   await db.close();
+   * });
+   */
+  export import sys = _Sys;
+  /**
+   * Promises and concurrency: map with a limit, queues with priorities,
+   * mutexes, polling, and friendlier `Promise.allSettled`.
+   *
+   * @example
+   * const pages = await async.map(urls, (url) => fetchPage(url), { concurrency: 5 });
+   *
+   * const limit = async.limit(2);
+   * await Promise.all(files.map((file) => limit(() => upload(file))));
+   *
+   * await async.poll(() => isServerReady(), { interval: 250, timeout: "10s" });
+   */
+  export import async = _Async;
+  /**
+   * Validate data with schemas, in the spirit of `zod`. Describe your data
+   * once and get both a runtime check with clear messages and the TypeScript
+   * type, `Infer<typeof schema>`. Schemas never change: `.min()` or
+   * `.optional()` return a new one.
+   *
+   * @example
+   * const User = s.object({
+   *   name: s.string().trim().min(2),
+   *   email: s.string().email().toLowerCase(),
+   *   age: s.number().int().min(18).optional(),
+   *   role: s.enum(["admin", "user"]).default("user"),
+   * });
+   *
+   * const user = User.parse(req.body);    // typed, or a ValidationError listing every issue
+   * const result = User.safeParse(input); // { success, data } or { success, error }
+   */
+  export import schema = _Schema;
+  /**
+   * An HTTP client on top of `fetch`: JSON by default, query objects, base
+   * URLs, timeouts, safe retries that respect `Retry-After`, typed errors,
+   * hooks, reusable clients and downloads with progress.
+   *
+   * @example
+   * const { data } = await http.get("https://api.github.com/repos/nodejs/node");
+   *
+   * const api = http.create({ baseURL: "https://api.example.com/v1/", auth: { bearer: process.env.TOKEN } });
+   * const { data: users } = await api.get("users", { query: { page: 2 } });
+   */
+  export import http = _Http;
+  /**
+   * Environment variables you can trust: `.env` loading, typed getters, and
+   * `validate()` to check your whole configuration at startup and report
+   * every problem at once.
+   *
+   * The `.env` file in the working directory is loaded when the package is
+   * required; variables that are already set are never overwritten. Set
+   * `NODE_COMFORT_DOTENV=false` to turn that off.
+   *
+   * @example
+   * const config = env.validate({
+   *   PORT: { type: "port", default: 3000 },
+   *   DATABASE_URL: { type: "url" },                  // required
+   *   CACHE_TTL: { type: "duration", default: "5m" }, // in ms
+   * });
+   * config.PORT; // a number, typed in your editor
+   */
+  export import env = _Env;
+  /**
+   * The errors node-comfort throws. They all extend `NodeComfortError` (itself
+   * a regular `Error`) and carry a stable `code`, so you can branch on the
+   * kind of failure without parsing messages.
+   *
+   * @example
+   * try {
+   *   await nc.http.get("https://api.example.com/users/42");
+   * } catch (error) {
+   *   if (error instanceof nc.errors.HttpError && error.status === 404) return null;
+   *   throw error;
+   * }
+   */
+  export import errors = _errors;
+  /**
+   * SQLite made pleasant, on the engine built into Node.js (22.13+): CRUD with
+   * rich filters, JSON and boolean columns, transactions, migrations and
+   * backups. Methods are synchronous, like the engine, but `await` still
+   * works. Errors are `SQLiteError`s. Values are always bound as parameters
+   * and names are checked, so there's no SQL injection through them.
+   *
+   * @example
+   * const db = new nc.SQLite("data/app.sqlite");
+   * db.createTable({
+   *   name: "users",
+   *   columns: {
+   *     id: { type: "INTEGER", primaryKey: true, autoincrement: true },
+   *     email: { type: "TEXT", notNull: true, unique: true },
+   *     settings: { type: "JSON", defaultValue: {} },
+   *   },
+   * });
+   * db.insert("users", { email: "ada@example.com", settings: { theme: "dark" } });
+   * db.getAll("users", { email: { like: "%@example.com" } }, { orderBy: "email", limit: 20 });
+   */
+  export import SQLite = _SQLite;
+  /**
+   * An in-memory cache with a size limit (the least recently used entries go
+   * first), expiry per entry, and stats. `getOrSet()` loads a missing value
+   * only once, even when many callers ask for it at the same moment.
+   *
+   * @example
+   * const users = new nc.Cache({ max: 1000, ttl: "5m" });
+   * const user = await users.getOrSet(id, () => db.users.find(id));
+   * users.stats; // { hits: 12, misses: 3, hitRate: 0.8, ... }
+   */
+  export import Cache = _Cache;
+  /**
+   * A small typed event emitter. Declare your events once, and your editor
+   * checks every event name and listener argument. `on()` returns a function
+   * that removes the listener, and you can `await` an event or loop over
+   * events with `for await`.
+   *
+   * @example
+   * const chat = new nc.Emitter<{ message: [text: string, from: string]; close: [] }>();
+   * const off = chat.on("message", (text, from) => console.log(`${from}: ${text}`));
+   * chat.emit("message", "hello", "ada");
+   * off();
+   * const [text] = await chat.waitFor("message", { timeout: "5s" });
+   */
+  export import Emitter = _Emitter;
+
+  // Flat helpers (logger, fs, checker, utils)
+  export import log = _Logger.log;
+  export import trace = _Logger.trace;
+  export import debug = _Logger.debug;
+  export import info = _Logger.info;
+  export import success = _Logger.success;
+  export import warn = _Logger.warn;
+  export import error = _Logger.error;
+  export import fatal = _Logger.fatal;
+  export import group = _Logger.group;
+  export import groupEnd = _Logger.groupEnd;
+  export import timeStart = _Logger.timeStart;
+  export import timeEnd = _Logger.timeEnd;
+  export import table = _Logger.table;
+  export import box = _Logger.box;
+  export import divider = _Logger.divider;
+  export import setLevel = _Logger.setLevel;
+  export import getLevel = _Logger.getLevel;
+  export import isLevelEnabled = _Logger.isLevelEnabled;
+  export import configure = _Logger.configure;
+  export import setTimestamp = _Logger.setTimestamp;
+  export import setDelimiter = _Logger.setDelimiter;
+  export import createLogger = _Logger.createLogger;
+  export import getEnv = _FS.getEnv;
+  export import createPath = _FS.createPath;
+  export import getFolder = _FS.getFolder;
+  export import getFile = _FS.getFile;
+  export import getFoldersIn = _FS.getFoldersIn;
+  export import getFilesIn = _FS.getFilesIn;
+  export import glob = _FS.glob;
+  export import find = _FS.find;
+  export import readFile = _FS.readFile;
+  export import readLines = _FS.readLines;
+  export import readJSON = _FS.readJSON;
+  export import writeFile = _FS.writeFile;
+  export import writeJSON = _FS.writeJSON;
+  export import appendFile = _FS.appendFile;
+  export import createFile = _FS.createFile;
+  export import createFolder = _FS.createFolder;
+  export import ensureFolder = _FS.ensureFolder;
+  export import ensureFile = _FS.ensureFile;
+  export import touch = _FS.touch;
+  export import deleteFolder = _FS.deleteFolder;
+  export import deleteFile = _FS.deleteFile;
+  export import remove = _FS.remove;
+  export import deleteFoldersIn = _FS.deleteFoldersIn;
+  export import deleteFilesIn = _FS.deleteFilesIn;
+  export import emptyFolder = _FS.emptyFolder;
+  export import copy = _FS.copy;
+  export import move = _FS.move;
+  export import copyFoldersIn = _FS.copyFoldersIn;
+  export import copyFolder = _FS.copyFolder;
+  export import copyFilesIn = _FS.copyFilesIn;
+  export import copyFile = _FS.copyFile;
+  export import moveFoldersIn = _FS.moveFoldersIn;
+  export import moveFolder = _FS.moveFolder;
+  export import moveFilesIn = _FS.moveFilesIn;
+  export import moveFile = _FS.moveFile;
+  export import exists = _FS.exists;
+  export import isFile = _FS.isFile;
+  export import isFolder = _FS.isFolder;
+  export import stat = _FS.stat;
+  export import fileSize = _FS.fileSize;
+  export import folderSize = _FS.folderSize;
+  export import hashFile = _FS.hashFile;
+  export import tempFolder = _FS.tempFolder;
+  export import sanitizeFilename = _FS.sanitizeFilename;
+  export import watch = _FS.watch;
+  export import isArray = _Checker.isArray;
+  export import isNumber = _Checker.isNumber;
+  export import isFinite = _Checker.isFinite;
+  export import isInteger = _Checker.isInteger;
+  export import isSafeInteger = _Checker.isSafeInteger;
+  export import isFloat = _Checker.isFloat;
+  export import isPositive = _Checker.isPositive;
+  export import isNegative = _Checker.isNegative;
+  export import isBoolean = _Checker.isBoolean;
+  export import isString = _Checker.isString;
+  export import isSymbol = _Checker.isSymbol;
+  export import isBigInt = _Checker.isBigInt;
+  export import isUndefined = _Checker.isUndefined;
+  export import isNull = _Checker.isNull;
+  export import isNil = _Checker.isNil;
+  export import isDefined = _Checker.isDefined;
+  export import isPrimitive = _Checker.isPrimitive;
+  export import isFunction = _Checker.isFunction;
+  export import isAsyncFunction = _Checker.isAsyncFunction;
+  export import isGeneratorFunction = _Checker.isGeneratorFunction;
+  export import isGenerator = _Checker.isGenerator;
+  export import isClass = _Checker.isClass;
+  export import isObject = _Checker.isObject;
+  export import isPlainObject = _Checker.isPlainObject;
+  export import isPromise = _Checker.isPromise;
+  export import isRegExp = _Checker.isRegExp;
+  export import isDate = _Checker.isDate;
+  export import isValidDate = _Checker.isValidDate;
+  export import isMap = _Checker.isMap;
+  export import isSet = _Checker.isSet;
+  export import isWeakMap = _Checker.isWeakMap;
+  export import isWeakSet = _Checker.isWeakSet;
+  export import isIterable = _Checker.isIterable;
+  export import isAsyncIterable = _Checker.isAsyncIterable;
+  export import isBuffer = _Checker.isBuffer;
+  export import isTypedArray = _Checker.isTypedArray;
+  export import isError = _Checker.isError;
+  export import isEmpty = _Checker.isEmpty;
+  export import isBlank = _Checker.isBlank;
+  export import isArrayOf = _Checker.isArrayOf;
+  export import isOneOf = _Checker.isOneOf;
+  export import isEmail = _Checker.isEmail;
+  export import isURL = _Checker.isURL;
+  export import isUUID = _Checker.isUUID;
+  export import isJSON = _Checker.isJSON;
+  export import isNumeric = _Checker.isNumeric;
+  export import isIP = _Checker.isIP;
+  export import isIPv4 = _Checker.isIPv4;
+  export import isIPv6 = _Checker.isIPv6;
+  export import isPort = _Checker.isPort;
+  export import isHex = _Checker.isHex;
+  export import isHexColor = _Checker.isHexColor;
+  export import isBase64 = _Checker.isBase64;
+  export import isSemver = _Checker.isSemver;
+  export import isISODate = _Checker.isISODate;
+  export import isSlug = _Checker.isSlug;
+  export import isAlpha = _Checker.isAlpha;
+  export import isAlphanumeric = _Checker.isAlphanumeric;
+  export import isCreditCard = _Checker.isCreditCard;
+  export import isJWT = _Checker.isJWT;
+  export import assert = _Checker.assert;
+  export import assertType = _Checker.assertType;
+  export import wait = _Utils.wait;
+  export import when = _Utils.when;
+  export import dontCrash = _Utils.dontCrash;
+  export import JSONString = _Utils.JSONString;
+  export import JSONParse = _Utils.JSONParse;
+
+  // Types
+  export import AnyTypedArray = _Checker.AnyTypedArray;
+  export import ArgsOptions = _Cli.ArgsOptions;
+  export import BorderStyle = _Cli.BorderStyle;
+  export import BoxOptions = _Cli.BoxOptions;
+  export import CacheOptions = _Cache.CacheOptions;
+  export import CacheRemovalReason = _Cache.CacheRemovalReason;
+  export import CacheSetOptions = _Cache.CacheSetOptions;
+  export import CacheStats = _Cache.CacheStats;
+  export import CalendarOptions = _Time.CalendarOptions;
+  export import CalendarUnit = _Time.CalendarUnit;
+  export import Change = _Obj.Change;
+  export import ChangeResult = _SQLite.ChangeResult;
+  export import Choice = _Cli.Choice;
+  export import ClosestOptions = _Str.ClosestOptions;
+  export import CoerceBuilders = _Schema.CoerceBuilders;
+  export import ColorChain = _Color.ColorChain;
+  export import ColorHelpers = _Color.ColorHelpers;
+  export import ColorLevel = _Color.ColorLevel;
+  export import ColorMethods = _Color.ColorMethods;
+  export import ColorModule = _Color.ColorModule;
+  export import ColorStyleProps = _Color.ColorStyleProps;
+  export import ColorStyles = _Color.ColorStyles;
+  export import ColumnDefinition = _SQLite.ColumnDefinition;
+  export import ColumnInfo = _SQLite.ColumnInfo;
+  export import ColumnType = _SQLite.ColumnType;
+  export import CompactOptions = _Obj.CompactOptions;
+  export import CompareOptions = _Str.CompareOptions;
+  export import ConfirmOptions = _Cli.ConfirmOptions;
+  export import CopyFileOptions = _FS.CopyFileOptions;
+  export import CopyFilesOptions = _FS.CopyFilesOptions;
+  export import CopyFolderOptions = _FS.CopyFolderOptions;
+  export import CopyFoldersOptions = _FS.CopyFoldersOptions;
+  export import CopyOptions = _FS.CopyOptions;
+  export import CronOptions = _Time.CronOptions;
+  export import CronSpec = _Time.CronSpec;
+  export import CurrencyOptions = _Num.CurrencyOptions;
+  export import DateInput = _Time.DateInput;
+  export import DebouncedFunction = _Func.DebouncedFunction;
+  export import DebounceOptions = _Func.DebounceOptions;
+  export import DecodedJWT = _Crypto.DecodedJWT;
+  export import DecryptOptions = _Crypto.DecryptOptions;
+  export import DeepReadonly = _Obj.DeepReadonly;
+  export import Deferred = _Async.Deferred;
+  export import DigestEncoding = _Crypto.DigestEncoding;
+  export import DontCrashController = _Utils.DontCrashController;
+  export import DontCrashEvent = _Utils.DontCrashEvent;
+  export import DurationUnit = _Time.DurationUnit;
+  export import EncryptOptions = _Crypto.EncryptOptions;
+  export import EnvConfig = _Env.EnvConfig;
+  export import EnvGetterOptions = _Env.EnvGetterOptions;
+  export import EnvLoadOptions = _Env.EnvLoadOptions;
+  export import EnvParseOptions = _Env.EnvParseOptions;
+  export import EnvVarSpec = _Env.EnvVarSpec;
+  export import EnvVarValue = _Env.EnvVarValue;
+  export import EventMap = _Emitter.EventMap;
+  export import EveryOptions = _Time.EveryOptions;
+  export import FindOptions = _FS.FindOptions;
+  export import FlagSpec = _Cli.FlagSpec;
+  export import FlagValue = _Cli.FlagValue;
+  export import ForeignKeyAction = _SQLite.ForeignKeyAction;
+  export import FormatBytesOptions = _Num.FormatBytesOptions;
+  export import FormatDateOptions = _Time.FormatDateOptions;
+  export import FormatDurationOptions = _Time.FormatDurationOptions;
+  export import FormatNumberOptions = _Num.FormatNumberOptions;
+  export import GlobOptions = _FS.GlobOptions;
+  export import HashOptions = _Crypto.HashOptions;
+  export import HashPasswordOptions = _Crypto.HashPasswordOptions;
+  export import HttpBody = _Http.HttpBody;
+  export import HttpClient = _Http.HttpClient;
+  export import HttpHooks = _Http.HttpHooks;
+  export import HttpMethod = _Http.HttpMethod;
+  export import HttpOptions = _Http.HttpOptions;
+  export import HttpRequestConfig = _Http.HttpRequestConfig;
+  export import HttpResponse = _Http.HttpResponse;
+  export import HttpRetryOptions = _Http.HttpRetryOptions;
+  export import IndexDefinition = _SQLite.IndexDefinition;
+  export import Infer = _Schema.Infer;
+  export import InsertResult = _SQLite.InsertResult;
+  export import IsBase64Options = _Checker.IsBase64Options;
+  export import IsURLOptions = _Checker.IsURLOptions;
+  export import IsUUIDOptions = _Checker.IsUUIDOptions;
+  export import Iteratee = _Arr.Iteratee;
+  export import JWTAlgorithm = _Crypto.JWTAlgorithm;
+  export import JWTClaims = _Crypto.JWTClaims;
+  export import Limiter = _Async.Limiter;
+  export import LineReader = _Cli.LineReader;
+  export import ListOptions = _FS.ListOptions;
+  export import LogFileOptions = _Logger.LogFileOptions;
+  export import Logger = _Logger.Logger;
+  export import LoggerOptions = _Logger.LoggerOptions;
+  export import LogLevel = _Logger.LogLevel;
+  export import LogStream = _Logger.LogStream;
+  export import MapOptions = _Async.MapOptions;
+  export import MaskOptions = _Str.MaskOptions;
+  export import MemoizedFunction = _Func.MemoizedFunction;
+  export import MemoizeOptions = _Func.MemoizeOptions;
+  export import MergeOptions = _Obj.MergeOptions;
+  export import Message = _Schema.Message;
+  export import Migration = _SQLite.Migration;
+  export import Mutex = _Async.Mutex;
+  export import NodeComfortErrorOptions = _errors.NodeComfortErrorOptions;
+  export import NullishToUndefined = _Obj.NullishToUndefined;
+  export import ObjectOutput = _Schema.ObjectOutput;
+  export import OrdinalOptions = _Num.OrdinalOptions;
+  export import Page = _Arr.Page;
+  export import ParseBytesOptions = _Num.ParseBytesOptions;
+  export import ParseContext = _Schema.ParseContext;
+  export import ParsedArgs = _Cli.ParsedArgs;
+  export import ParsedFlags = _Cli.ParsedFlags;
+  export import ParsedSnowflake = _Id.ParsedSnowflake;
+  export import PathInput = _Obj.PathInput;
+  export import PathLeaf = _Obj.PathLeaf;
+  export import Paths = _Obj.Paths;
+  export import PathStep = _Obj.PathStep;
+  export import PathValue = _Obj.PathValue;
+  export import PluralForms = _Str.PluralForms;
+  export import PluralOptions = _Str.PluralOptions;
+  export import PollOptions = _Async.PollOptions;
+  export import Primitive = _Checker.Primitive;
+  export import ProgressBar = _Cli.ProgressBar;
+  export import ProgressOptions = _Cli.ProgressOptions;
+  export import PromptOptions = _Cli.PromptOptions;
+  export import QueryOptions = _SQLite.QueryOptions;
+  export import QueryParams = _Http.QueryParams;
+  export import Queue = _Async.Queue;
+  export import QueueAddOptions = _Async.QueueAddOptions;
+  export import QueueOptions = _Async.QueueOptions;
+  export import RandomStringOptions = _Str.RandomStringOptions;
+  export import ReadJSONOptions = _FS.ReadJSONOptions;
+  export import RefineOptions = _Schema.RefineOptions;
+  export import RelativeOptions = _Time.RelativeOptions;
+  export import RetryOptions = _Func.RetryOptions;
+  export import RunOptions = _Sys.RunOptions;
+  export import RunResult = _Sys.RunResult;
+  export import SafeParseResult = _Schema.SafeParseResult;
+  export import ScheduledTask = _Time.ScheduledTask;
+  export import SelectOptions = _Cli.SelectOptions;
+  export import Settled = _Async.Settled;
+  export import Shape = _Schema.Shape;
+  export import ShutdownOptions = _Sys.ShutdownOptions;
+  export import SignJWTOptions = _Crypto.SignJWTOptions;
+  export import Simplify = _Schema.Simplify;
+  export import SlugifyOptions = _Str.SlugifyOptions;
+  export import SnowflakeOptions = _Id.SnowflakeOptions;
+  export import SortByOptions = _Arr.SortByOptions;
+  export import SortDirection = _SQLite.SortDirection;
+  export import SortKey = _Arr.SortKey;
+  export import Spinner = _Cli.Spinner;
+  export import SpinnerOptions = _Cli.SpinnerOptions;
+  export import SQLiteOptions = _SQLite.SQLiteOptions;
+  export import StartOfUnit = _Time.StartOfUnit;
+  export import Step = _Schema.Step;
+  export import Stopwatch = _Time.Stopwatch;
+  export import StyleEntry = _Color.StyleEntry;
+  export import StyleName = _Color.StyleName;
+  export import SystemInfo = _Sys.SystemInfo;
+  export import TableColumn = _Cli.TableColumn;
+  export import TableConstraint = _SQLite.TableConstraint;
+  export import TableDefinition = _SQLite.TableDefinition;
+  export import TableHandle = _SQLite.TableHandle;
+  export import TableOptions = _Cli.TableOptions;
+  export import TemplateOptions = _Str.TemplateOptions;
+  export import ThrottledFunction = _Func.ThrottledFunction;
+  export import ThrottleOptions = _Func.ThrottleOptions;
+  export import TimeZoneOptions = _Time.TimeZoneOptions;
+  export import TokenEncoding = _Id.TokenEncoding;
+  export import TOTPOptions = _Crypto.TOTPOptions;
+  export import TOTPURIOptions = _Crypto.TOTPURIOptions;
+  export import TruncateOptions = _Str.TruncateOptions;
+  export import ValidationIssue = _errors.ValidationIssue;
+  export import VarianceOptions = _Num.VarianceOptions;
+  export import VerifyJWTOptions = _Crypto.VerifyJWTOptions;
+  export import VerifyTOTPOptions = _Crypto.VerifyTOTPOptions;
+  export import WaitForOptions = _Emitter.WaitForOptions;
+  export import WaitOptions = _Utils.WaitOptions;
+  export import Watcher = _FS.Watcher;
+  export import WatchOptions = _FS.WatchOptions;
+  export import WeekOptions = _Time.WeekOptions;
+  export import WhenOptions = _Utils.WhenOptions;
+  export import WhenTask = _Utils.WhenTask;
+  export import Where = _SQLite.Where;
+  export import WhereOperators = _SQLite.WhereOperators;
+  export import WhereValue = _SQLite.WhereValue;
+  export import WrapOptions = _Str.WrapOptions;
+  export import WriteFileOptions = _FS.WriteFileOptions;
+  export import WriteJSONOptions = _FS.WriteJSONOptions;
+
+  // Self references
+  /**
+   * The whole toolkit. Lets you write `const { nc } = require("@ix-xs/node-comfort")`
+   * or `import { nc } from "@ix-xs/node-comfort"`.
+   */
+  export const nc: typeof import("./index.js");
+  /** The whole toolkit (same object as `nc`). */
+  export const nodeComfort: typeof import("./index.js");
+}
+
+export = nodeComfort;