yavascript.d.ts

// NOTE: This copy of yavascript.d.ts reflects what is in git.
// APIs may differ from what you have installed.
// Run `yavascript --print-types > yavascript.d.ts` to get the types
// corresponding to your specific `yavascript` binary.

// ===============
// ---------------
// YavaScript APIs
// ---------------
// ===============
/**
 * Prints a link to the YavaScript help docs for the currently-running version
 * of YavaScript.
 *
 * For the latest help docs, see:
 * https://github.com/suchipi/yavascript/blob/main/meta/generated-docs/README.md
 *
 * **Example**
 * ```ts
 * help();
 * ```
 */
declare function help(): void;

/**
 * The `yavascript` global contains metadata about the currently-running
 * yavascript binary, as well as access to yavascript's compilers for
 * compile-to-js languages.
 *
 * **Example**
 * ```ts
 * console.log(yavascript.version, yavascript.arch, yavascript.ecmaVersion);
 * ```
 */
declare const yavascript: {
  /**
   * The version of the currently-running yavascript binary.
   *
   * Will be something formatted like one of these:
   * - "v0.0.7"
   * - "v0.1.3-alpha"
   * - "git-286a3a336849"
   * - "git-286a3a336849-dirty"
   *
   * Or, more formally: either a "V" version string or a "GIT" version string:
   * - "V" version strings start with the character 'v', followed by a semver
   *   version string, optionally followed by the character '-' and any
   *   arbitrary content afterwards.
   * - "GIT" version strings start with the prefix "git-", followed by the
   *   first 12 digits of a git commit SHA, optionally followed by the
   *   character '-' and any arbitrary content afterwards.
   *
   * **Example**
   * ```ts
   * if (yavascript.version.startsWith("git-")) {
   *   console.warn("Running a development build of yavascript");
   * }
   * ```
   */
  version: string;

  /**
   * The processor architecture of the currently-running `yavascript` binary.
   *
   * **Example**
   * ```ts
   * const downloadName = `my-tool-${yavascript.arch}.tar.gz`;
   * console.log(downloadName);
   * ```
   */
  arch: "x86_64" | "arm64";

  /**
   * The version of the ecma262 standard supported by the currently-running
   * yavascript binary.
   *
   * Possible values (depending on yavascript version): "ES2020", "ES2023".
   *
   * **Example**
   * ```ts
   * console.log(`This yavascript supports ${yavascript.ecmaVersion} syntax`);
   * ```
   */
  ecmaVersion: string;

  /**
   * The compilers yavascript uses internally to load files.
   *
   * Each function returns a JavaScript source code string.
   *
   * **Example**
   * ```ts
   * const { ts, coffee } = yavascript.compilers;
   * console.log(ts("const x: number = 1;"));
   * console.log(coffee("x = 1"));
   * ```
   */
  compilers: {
    /**
     * The function yavascript uses internally to load JavaScript files.
     *
     * You might think this would be a no-op, but we do some CommonJS/ECMAScript
     * Module interop transformations here.
     *
     * **Example**
     * ```ts
     * const output = yavascript.compilers.js("export const x = 1;", {
     *   filename: "x.js",
     * });
     * console.log(output);
     * ```
     */
    js(
      code: string,
      options?: { filename?: string | Path; expression?: boolean },
    ): string;

    /**
     * The function yavascript uses internally to load [TypeScript JSX](https://www.typescriptlang.org/docs/handbook/jsx.html) files.
     *
     * yavascript uses [Sucrase 3.35.0](https://sucrase.io/) to load TypeScript JSX syntax. yavascript doesn't do typechecking of TypeScript syntax.
     *
     * **Example**
     * ```ts
     * const tsx = "const link = <a href={url as string} />;";
     * console.log(yavascript.compilers.tsx(tsx));
     * ```
     */
    tsx(
      code: string,
      options?: { filename?: string | Path; expression?: boolean },
    ): string;

    /**
     * The function yavascript uses internally to load [TypeScript](https://www.typescriptlang.org/) files.
     *
     * yavascript uses [Sucrase 3.35.0](https://sucrase.io/) to load TypeScript syntax. yavascript doesn't do typechecking of TypeScript syntax.
     *
     * **Example**
     * ```ts
     * const output = yavascript.compilers.ts("const x: number = 1;", {
     *   filename: "x.ts",
     * });
     * console.log(output);
     * ```
     */
    ts(
      code: string,
      options?: { filename?: string | Path; expression?: boolean },
    ): string;

    /**
     * The function yavascript uses internally to load JSX files.
     *
     * yavascript uses [Sucrase 3.35.0](https://sucrase.io/) to load JSX syntax.
     *
     * See {@link JSX} for info about configuring JSX pragma, swapping out the
     * default `createElement` implementation, etc.
     *
     * **Example**
     * ```ts
     * const jsx = 'const link = <a href="https://example.com" />;';
     * console.log(yavascript.compilers.jsx(jsx));
     * ```
     */
    jsx(
      code: string,
      options?: { filename?: string | Path; expression?: boolean },
    ): string;

    /**
     * The function yavascript uses internally to load [CoffeeScript](https://coffeescript.org/) files.
     *
     * yavascript embeds CoffeeScript 2.7.0.
     *
     * **Example**
     * ```ts
     * console.log(yavascript.compilers.coffee("square = (x) -> x * x"));
     * ```
     */
    coffee(
      code: string,
      options?: { filename?: string | Path; expression?: boolean },
    ): string;

    /**
     * The function yavascript uses internally to load [Civet](https://civet.dev/) files.
     *
     * yavascript embeds Civet 0.11.16.
     *
     * **Example**
     * ```ts
     * const civet = "square := (x: number) => x * x";
     * console.log(yavascript.compilers.civet(civet));
     * ```
     */
    civet(
      code: string,
      options?: { filename?: string | Path; expression?: boolean },
    ): string;

    /**
     * The function yavascript uses internally to load files which don't have an
     * extension.
     *
     * It tries to parse the file as each of the following languages, in order,
     * until it finds one which doesn't have a syntax error:
     *
     * - JSX
     * - TSX
     * - Civet
     * - CoffeeScript
     *
     * If none of the languages work, the file's original content gets used so
     * that a syntax error can be reported to the user.
     *
     * **Example**
     * ```ts
     * const output = yavascript.compilers.autodetect("square = (x) -> x * x");
     * console.log(output);
     * ```
     */
    autodetect(
      code: string,
      options?: { filename?: string | Path; expression?: boolean },
    ): string;
  };

  /**
   * Returns the .d.ts types for all the APIs in this version of yavascript as a
   * string.
   *
   * It's the same string that gets logged when you run yavascript with the
   * `--print-types` command-line flag.
   *
   * **Example**
   * ```ts
   * writeFile("yavascript.d.ts", yavascript.getTypesDts());
   * ```
   */
  getTypesDts(): string;
};

/**
 * An object representing the process's environment variables. You can read
 * from it to read environment variables, write into it to set environment
 * variables, and/or delete properties from it to unset environment variables.
 * Any value you write will be coerced into a string.
 *
 * **Example**
 * ```ts
 * console.log(env.HOME);
 * env.NODE_ENV = "production";
 * delete env.DEBUG;
 * ```
 */
declare const env: { [key: string]: string | undefined };

/**
 * A function which reads an environment variable and returns an appropriate
 * boolean based on the string value of the environment variable.
 *
 * - If the environment variable is not set, The `fallback` parameter is returned.
 * - If the value is "1", "true", "True", or "TRUE", the boolean `true` is returned.
 * - If the value is "0", "false", "False", or "FALSE", the boolean `false` is returned.
 * - If the environment variable is defined but its value isn't one of the
 *   values listed above, a warning is printed and the `fallback` parameter is returned.
 *
 * Generally, the `fallback` parameter is set to `true`, `false`, or `null`.
 *
 * @param key The environment variable to read.
 * @param fallback Value to return if the environment variable is unset or not
 * coercable to boolean.
 * @param logging logger override for the warning printed when an environment
 * variable has an unsupported value. Defaults to {@link logger}.
 *
 * **Example**
 * ```ts
 * const verbose = readEnvBool("VERBOSE", false);
 * if (verbose) {
 *   console.log("verbose logging enabled");
 * }
 * ```
 */
declare function readEnvBool<T>(
  key: string,
  fallback: T,
  logging?: {
    warn?: (...args: Array<any>) => void;
  },
): boolean | T;

/**
 * A function which parses command line `--flags` into an object of flags and an
 * array of positional arguments. This function is opinionated; if it doesn't
 * meet your needs, you can parse the {@link scriptArgs} global manually.
 *
 * Flags `--like-this`, `--like_this`, or `--LIKE_THIS` get converted into
 * property names `likeThis` on the returned flags object.
 *
 * Flags like this: `-v` get converted into into property names like this: `v`
 * on the returned flags object.
 *
 * Anything that appears after `--` is considered a positional argument instead
 * of a flag. `--` is not present in the returned positional arguments Array.
 *
 * `parseScriptArgs` accepts two optional parameters: `hints` and `argv`.
 *
 * ## hints
 *
 * If present, `hints` should be an object whose keys are flag names (in
 * lowerCamelCase) and whose values indicate what type to treat that flag as.
 * Valid property values are `String`, `Boolean`, `Number`, and `Path`. `Path`
 * will resolve relative paths into absolute paths for you. If no hints object
 * is specified, `parseScriptArgs` will do its best to guess the types.
 *
 * ## argv
 *
 * The `argv` parameter, if present, should be an array containing the command
 * line flags you want to parse. If you don't provide one, `scriptArgs.slice(2)`
 * will be used (we slice 2 in order to skip the yavascript binary and script
 * name). If you pass in an array here, it should only contain command-line
 * flags, not the binary being called.
 *
 * ## Return Value
 *
 * `parseScriptArgs` returns an object with three properties: `flags`, `args`,
 * and `metadata`.
 *
 * - `flags` is an object whose keys are lowerCamelCase flag names and whose
 *   values are strings, booleans, numbers, or `Path`s corresponding to the
 *   input command-line args.
 * - `args` is an Array of positional arguments, as found on the command-line.
 * - `metadata` contains information about what name and type the flags got
 *   mapped to.
 *
 * @param hints - An object whose keys are flag names (in lowerCamelCase) and
 * whose values indicate what type to treat that flag as. Valid property values
 * are `String`, `Boolean`, `Number`, and `Path`. `Path` will resolve relative
 * paths into absolute paths for you. If no hints object is specified,
 * `parseScriptArgs` will do its best to guess, based on the command-line args.
 * @param argv - An array containing the command line flags you want to parse.
 * If unspecified, `scriptArgs.slice(2)` will be used (we slice 2 in order to
 * skip the yavascript binary and script name). If you pass in an array here, it
 * should only contain command-line flags, not the binary being called.
 *
 * @returns A {@link ParseScriptArgsResult}, which is an object with three
 * properties: `flags`, `args`, and `metadata`. `flags` is an object whose keys
 * are camelCase flag names and whose values are strings, booleans, numbers, or
 * `Path`s corresponding to the input command-line args. `args` is an Array of
 * positional arguments, as found on the command-line. `metadata` contains
 * information about what name and type the flags got mapped to.
 *
 * **Example**
 * ```ts
 * const { flags, args } = parseScriptArgs({
 *   output: Path,
 *   verbose: Boolean,
 * });
 * console.log(flags.output, flags.verbose, args);
 * ```
 */
declare function parseScriptArgs(
  hints?: {
    [key: string]: typeof String | typeof Boolean | typeof Number | typeof Path;
  },
  args?: Array<string>,
): ParseScriptArgsResult;

/**
 * The return type of {@link parseScriptArgs}.
 *
 * The `flags` property contains the values for any command-line `--flags`, with
 * key names converted to `lowerCamelCase`.
 *
 * The `args` property contains an array of those command-line arguments which
 * weren't associated with a flag.
 *
 * The `metadata` property contains information about the parsing process,
 * including what case changes were applied to the keys, which hints were used,
 * and which properties had their type guessed because no corresponding hint was
 * available.
 *
 * **Example**
 * ```ts
 * const result: ParseScriptArgsResult = parseScriptArgs();
 * console.log(result.flags, result.args, result.metadata);
 * ```
 */
declare interface ParseScriptArgsResult {
  /**
   * The values for any command-line `--flags`, with key names converted to `lowerCamelCase`.
   *
   * **Example**
   * ```ts
   * const { flags } = parseScriptArgs({ dryRun: Boolean }, ["--dry-run"]);
   * console.log(flags.dryRun); // true
   * ```
   */
  flags: { [key: string]: any };
  /**
   * An array of those command-line arguments which weren't associated with a flag.
   *
   * **Example**
   * ```ts
   * const argv = ["--verbose", "one.txt", "two.txt"];
   * const { args } = parseScriptArgs({ verbose: Boolean }, argv);
   * console.log(args); // ["one.txt", "two.txt"]
   * ```
   */
  args: Array<string>;
  /**
   * Information about the parsing process, including what case changes were
   * applied to the keys, which hints were used, and which properties had their
   * type guessed because no corresponding hint was available.
   *
   * **Example**
   * ```ts
   * const argv = ["--dry-run", "--count", "3"];
   * const { metadata } = parseScriptArgs({ count: Number }, argv);
   * console.log(metadata);
   * // {
   * //   keys: {
   * //     "--dry-run": "dryRun",
   * //     "--count": "count",
   * //   },
   * //   hints: {
   * //     count: "number",
   * //   },
   * //   guesses: {
   * //     dryRun: "boolean",
   * //   },
   * // }
   * ```
   */
  metadata: {
    /**
     * An object whose keys are the verbatim flags from the command-line, and
     * whose values are the lowerCamelCase names they were converted to in the
     * `flags` property of the {@link ParseScriptArgsResult}.
     *
     * **Example**
     * ```ts
     * const { metadata } = parseScriptArgs({}, ["--dry-run"]);
     * console.log(metadata.keys["--dry-run"]); // "dryRun"
     * ```
     */
    keys: {
      [key: string]: string | undefined;
    };
    /**
     * An object whose keys are the lowerCamelCase flag names, and whose values
     * are strings indicating the hint values that were specified for those
     * flags.
     *
     * **Example**
     * ```ts
     * const hints = { count: Number };
     * const { metadata } = parseScriptArgs(hints, ["--count", "3"]);
     * console.log(metadata.hints.count); // "number"
     * ```
     */
    hints: {
      [key: string]: "path" | "number" | "boolean" | "string" | undefined;
    };
    /**
     * An object indicating which flags we inferred the type of, because no
     * corresponding hint was present.
     *
     * The keys are the lowerCamelCase flag names, and the values are strings
     * indicating what type we guessed for that flag.
     *
     * If you're seeing incorrect inference, consider passing a `hints` argument
     * to {@link parseScriptArgs}.
     *
     * **Example**
     * ```ts
     * const { metadata } = parseScriptArgs({}, ["--count", "3"]);
     * console.log(metadata.guesses.count); // "number"
     * ```
     */
    guesses: {
      [key: string]: "number" | "boolean" | "string" | undefined;
    };
  };
}

/**
 * Read the contents of a file from disk.
 *
 * With no options specified, it reads the file as UTF-8 and returns a string:
 *
 * ```ts
 * const contents = readFile("README.md");
 * console.log(contents);
 * // "# yavascript\n\nYavaScript is a cross-platform bash-like script runner and repl which is distributed as a single\nstatically-linked binary..."
 * ```
 *
 * But, if you pass `{ binary: true }` as the second argument, it returns an
 * ArrayBuffer containing the raw bytes from the file:
 *
 * ```ts
 * const contents = readFile("README.md", { binary: true });
 * console.log(contents);
 * // ArrayBuffer {
 * //   │0x00000000│ 23 20 79 61 76 61 73 63 72 69 70 74 0A 0A 59 61
 * //   │0x00000010│ 76 61 53 63 72 69 70 74 20 69 73 20 61 20 63 72
 * //   │0x00000020│ 6F 73 73 2D 70 6C 61 74 66 6F 72 6D 20 62 61 73
 * //   │0x00000030│ 68 2D 6C 69 6B 65 20 73 63 72 69 70 74 20 72 75
 * // ...
 * ```
 */
declare const readFile: {
  /**
   * Read the contents of a file from disk, as a UTF-8 string.
   *
   * **Example**
   * ```ts
   * const text = readFile("README.md");
   * console.log(text.length);
   * ```
   */
  (path: string | Path): string;

  /**
   * Read the contents of a file from disk, as a UTF-8 string.
   *
   * **Example**
   * ```ts
   * const text = readFile("README.md", {});
   * console.log(text.length);
   * ```
   */
  (path: string | Path, options: {}): string;

  /**
   * Read the contents of a file from disk, as a UTF-8 string.
   *
   * **Example**
   * ```ts
   * const text = readFile("README.md", { binary: false });
   * console.log(text.length);
   * ```
   */
  (path: string | Path, options: { binary: false }): string;

  /**
   * Read the contents of a file from disk, as an ArrayBuffer.
   *
   * **Example**
   * ```ts
   * const buffer = readFile("image.png", { binary: true });
   * console.log(buffer.byteLength);
   * ```
   */
  (path: string | Path, options: { binary: true }): ArrayBuffer;
};

/**
 * Write the contents of a string or ArrayBuffer to a file.
 *
 * Strings are written using the UTF-8 encoding.
 *
 * **Example**
 * ```ts
 * writeFile("notes.txt", "remember to buy milk\n");
 * writeFile("bytes.bin", new Uint8Array([1, 2, 3]).buffer);
 * ```
 */
declare function writeFile(
  path: string | Path,
  data: string | ArrayBuffer,
): void;

/**
 * Function which returns true if the path points to a regular file.
 *
 * **Example**
 * ```ts
 * if (isFile("README.md")) {
 *   console.log(readFile("README.md"));
 * }
 * ```
 */
declare function isFile(path: string | Path): boolean;

/**
 * Function which returns true if the path points to a directory, or if the
 * path points to a symlink which points to a directory. Otherwise, it returns
 * false.
 *
 * **Example**
 * ```ts
 * if (!isDir("build")) {
 *   mkdir("build");
 * }
 * ```
 */
declare function isDir(path: string | Path): boolean;

/**
 * Returns true if the path points to a symlink.
 *
 * **Example**
 * ```ts
 * if (isLink("link-to-readme")) {
 *   console.log(readlink("link-to-readme"));
 * }
 * ```
 */
declare function isLink(path: string | Path): boolean;

/**
 * Returns true if the resource at the provided path can be executed by the
 * current user.
 *
 * If nothing exists at that path, an error will be thrown.
 *
 * **Example**
 * ```ts
 * if (!isExecutable("script.sh")) {
 *   chmod("add", { user: "execute" }, "script.sh");
 * }
 * ```
 */
declare function isExecutable(path: string | Path): boolean;

/**
 * Returns true if the resource at the provided path can be read by the current
 * user.
 *
 * If nothing exists at that path, an error will be thrown.
 *
 * **Example**
 * ```ts
 * if (isReadable("notes.txt")) {
 *   console.log(readFile("notes.txt"));
 * }
 * ```
 */
declare function isReadable(path: string | Path): boolean;

/**
 * Returns true if a resource at the provided path could be written to by the
 * current user.
 *
 * **Example**
 * ```ts
 * if (isWritable("notes.txt")) {
 *   writeFile("notes.txt", "remember to buy milk\n");
 * }
 * ```
 */
declare function isWritable(path: string | Path): boolean;

/**
 * Delete the file or directory at the specified path.
 *
 * If the directory isn't empty, its contents will be deleted, too.
 *
 * Provides the same functionality as the command `rm -r`.
 *
 * **Example**
 * ```ts
 * if (exists("build")) {
 *   remove("build");
 * }
 * ```
 */
declare function remove(path: string | Path): void;

/**
 * Returns true if a file or directory exists at the specified path.
 *
 * Provides the same functionality as the command `test -e`.
 *
 * **Example**
 * ```ts
 * if (!exists("settings.toml")) {
 *   writeFile("settings.toml", 'name = "my-project"\n');
 * }
 * ```
 */
declare function exists(path: string | Path): boolean;

/**
 * Copies a file or folder from one location to another.
 * Folders are copied recursively.
 *
 * Provides the same functionality as the command `cp -R`.
 *
 * **Example**
 * ```ts
 * copy("README.md", "README.backup.md");
 * copy("src", "src-backup");
 * ```
 */
declare function copy(
  from: string | Path,
  to: string | Path,
  options?: CopyOptions,
): void;

/**
 * Options for {@link copy}.
 *
 * **Example**
 * ```ts
 * const options: CopyOptions = { whenTargetExists: "skip" };
 * copy("src", "src-backup", options);
 * ```
 */
declare type CopyOptions = {
  /**
   * What to do when attempting to copy something into a location where
   * something else already exists.
   *
   * Defaults to "error".
   *
   * **Example**
   * ```ts
   * copy("config.toml", "notes.txt", { whenTargetExists: "overwrite" });
   * ```
   */
  whenTargetExists?: "overwrite" | "skip" | "error";

  /**
   * Options which control logging.
   *
   * **Example**
   * ```ts
   * copy("src", "src-backup", {
   *   logging: { trace: console.error, info: console.error },
   * });
   * ```
   */
  logging?: {
    /**
     * If provided, this function will be called multiple times as `copy`
     * traverses the filesystem, to help you understand what's going on and/or
     * troubleshoot things. In most cases, it makes sense to use a logging
     * function here, like so:
     *
     * ```js
     * copy("./source", "./destination", {
     *   logging: { trace: console.log },
     * });
     * ```
     *
     * Defaults to the current value of {@link logger.trace}. `logger.trace`
     * defaults to a no-op function.
     */
    trace?: (...args: Array<any>) => void;

    /**
     * An optional, user-provided logging function to be used for informational
     * messages.
     *
     * Defaults to the current value of {@link logger.info}. `logger.info`
     * defaults to a function which writes to stderr.
     *
     * **Example**
     * ```ts
     * copy("src", "src-backup", {
     *   logging: { info: (...args) => console.error("[copy]", ...args) },
     * });
     * ```
     */
    info?: (...args: Array<any>) => void;
  };
};

/**
 * Rename the file or directory at the specified path.
 *
 * Provides the same functionality as the command `mv`.
 *
 * **Example**
 * ```ts
 * rename("notes.txt", "notes-old.txt");
 * ```
 */
declare function rename(from: string | Path, to: string | Path): void;

/**
 * A class which represents a filesystem path. The class contains various
 * methods that make it easy to work with filesystem paths; there are methods
 * for adding/removing path components, converting between absolute and relative
 * paths, getting the basename and dirname, and more.
 *
 * All functions in yavascript which accept path strings as arguments also
 * accept Path objects. As such, it is recommended that all filesystem paths in
 * your programs are Path objects rather than strings.
 *
 * Every Path object has two properties: `segments` and `separator`. `segments`
 * is an Array of strings containing all the non-slash portions of the path. For
 * example, the path "one/two/three" would have segments `["one", "two",
 * "three"]`. `separator` is which slash is used to separate the segments;
 * either `"/"` or `"\"`.
 *
 * A Path object can represent either a POSIX-style path or a win32-style path.
 * For the win32 style, UNC paths are supported. POSIX-style paths starting with
 * "/" (eg. "/usr/bin") have an empty string at the beginning of their segments
 * array to represent the left-hand-side of the leading slash. For instance,
 * "/usr/bin" would have segments `["", "usr", "bin"]`.
 *
 * **Example**
 * ```ts
 * const projectDir = new Path("/home/suchipi", "Code/my-project");
 * const readme = projectDir.concat("README.md");
 * console.log(readme.toString(), readme.segments, readme.separator);
 * ```
 */
declare class Path {
  /**
   * The character used to separate path segments on the current operating
   * system where yavascript is running.
   *
   * Its value is either a forward slash (`"/"`) or a backslash (`"\"`). Its value
   * is a backslash on windows, and a forward slash on all other operating
   * systems.
   *
   * **Example**
   * ```ts
   * console.log(Path.OS_SEGMENT_SEPARATOR);
   * ```
   */
  static readonly OS_SEGMENT_SEPARATOR: "/" | "\\";

  /**
   * The character used to separate entries within the system's `PATH`
   * environment variable on the current operating system where yavascript is
   * running.
   *
   * The `PATH` environment variable contains a list of folders wherein
   * command-line programs can be found, separated by either a colon (`:`) or a
   * semicolon (`;`). The value of `OS_ENV_VAR_SEPARATOR` is a semicolon on
   * windows, and a colon on all other operating systems.
   *
   * The `PATH` environment variable can be accessed by yavascript programs via
   * `env.PATH`. Therefore, one can contain a list of all entries in the `PATH`
   * environment variable via:
   *
   * ```ts
   * const entries: Array<string> = env.PATH.split(Path.OS_ENV_VAR_SEPARATOR);
   * ```
   */
  static readonly OS_ENV_VAR_SEPARATOR: ":" | ";";

  /**
   * A Set of filename extension strings that command-line programs may end with
   * on the current operating system where yavascript is running. For instance,
   * on Windows, programs often end with ".exe". Each of these strings contains
   * a leading dot (`.`).
   *
   * On windows, this value is based on the `PATHEXT` environment variable,
   * which defaults to ".COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC"
   * on Windows Vista and up. If `PATHEXT` is not defined, that default value is
   * used.
   *
   * On all other operating systems, this Set is empty.
   *
   * **Example**
   * ```ts
   * const extensions = Array.from(Path.OS_PROGRAM_EXTENSIONS);
   * console.log(extensions);
   * ```
   */
  static readonly OS_PROGRAM_EXTENSIONS: ReadonlySet<string>;

  /**
   * Returns a boolean indicating whether `other` is a Path instance.
   *
   * @param other - Any value
   *
   * **Example**
   * ```ts
   * function countSegments(input: string | Path) {
   *   return Path.isPath(input) ? input.segments.length : -1;
   * }
   * console.log(countSegments(pwd()), countSegments("README.md"));
   * ```
   */
  static isPath(other: unknown): other is Path;

  /**
   * Converts a string (or array of strings) into an array of path segment
   * strings (the parts between the slashes).
   *
   * Example:
   *
   * ```ts
   * const input = ["hi", "there/every/one", "yeah\\yup"];
   * const result = Path.splitToSegments(input);
   * // result is ["hi", "there", "every", "one", "yeah", "yup"]
   * ```
   */
  static splitToSegments(inputParts: Array<string> | string): Array<string>;

  /**
   * Searches the provided path string or strings for a path separator character
   * (either forward slash or backslash), and returns the one it finds. If
   * neither is found, it returns the `fallback` arg, which defaults to the
   * current OS's path segment separator (`Path.OS_SEGMENT_SEPARATOR`).
   *
   * **Example**
   * ```ts
   * console.log(Path.detectSeparator("C:\\Users\\suchipi")); // "\"
   * console.log(Path.detectSeparator("README.md", "/")); // "/"
   * ```
   */
  static detectSeparator<Fallback extends string | null = string>(
    input: Array<string> | string,
    // @ts-ignore might be instantiated with a different subtype
    fallback: Fallback = Path.OS_SEGMENT_SEPARATOR,
  ): string | Fallback;

  /**
   * Creates a new Path by concatenating the input path(s) and then resolving all
   * non-leading `.` and `..` segments. In other words:
   *
   * - Segments containing `.` are removed
   * - Segments containing `..` are removed, along with the segment preceding
   *   them.
   *
   * Note that any `.` or `..` segments at the beginning of the path (ie.
   * "leading segments") are not removed.
   *
   * **Example**
   * ```ts
   * const path = Path.normalize("/home/suchipi", "./Code/../Downloads");
   * console.log(path.toString()); // "/home/suchipi/Downloads"
   * ```
   */
  static normalize(
    ...inputs: Array<string | Path | Array<string | Path>>
  ): Path;

  /**
   * Returns a boolean indicating whether the provided path is absolute; that
   * is, whether it starts with either a slash (`/` or `\`) or a drive letter
   * (ie `C:`).
   *
   * Note that Windows UNC Paths (eg. `\\MYSERVER\share$\`) are considered
   * absolute.
   *
   * **Example**
   * ```ts
   * console.log(Path.isAbsolute("/usr/bin")); // true
   * console.log(Path.isAbsolute("./src/index.ts")); // false
   * ```
   */
  static isAbsolute(path: string | Path): boolean;

  /**
   * Creates a new Path containing the user-provided segments and separator. In
   * most cases, you won't need to do this, and can use `new Path(...)` instead.
   *
   * If unspecified, the `separator` parameter defaults to
   * `Path.OS_SEGMENT_SEPARATOR`.
   *
   * **Example**
   * ```ts
   * const path = Path.fromRaw(["", "usr", "bin"], "/");
   * console.log(path.toString()); // "/usr/bin"
   * ```
   */
  static fromRaw(segments: Array<string>, separator?: string): Path;

  /**
   * Creates a new Path object using the provided input(s), which will be
   * concatenated together in order left-to-right.
   *
   * **Example**
   * ```ts
   * const path = new Path("/usr", "local/bin", ["node"]);
   * console.log(path.toString()); // "/usr/local/bin/node"
   * ```
   */
  constructor(...inputs: Array<string | Path | Array<string | Path>>);

  /**
   * An array of the path segments that make up this path.
   *
   * For `/tmp/foo.txt`, it'd be `["", "tmp", "foo.txt"]`.
   *
   * For `C:\something\somewhere.txt`, it'd be `["C:", "something", "somewhere.txt"]`.
   *
   * **Example**
   * ```ts
   * const path = new Path("/tmp/foo.txt");
   * console.log(path.segments); // ["", "tmp", "foo.txt"]
   * ```
   */
  segments: Array<string>;

  /**
   * The path separator that should be used to turn this path into a string.
   *
   * Will be either `"/"` or `"\"`.
   *
   * **Example**
   * ```ts
   * const path = new Path("C:\\Users\\suchipi");
   * console.log(path.separator); // "\"
   * ```
   */
  separator: string;

  /**
   * Creates a new Path by resolving all non-leading `.` and `..` segments in
   * the target Path. In other words:
   *
   * - Segments containing `.` are removed
   * - Segments containing `..` are removed, along with the segment preceding
   *   them.
   *
   * Note that any `.` or `..` segments at the beginning of the path (ie.
   * "leading segments") are not removed.
   *
   * **Example**
   * ```ts
   * const path = new Path("/home/suchipi/./Code/../Downloads");
   * console.log(path.normalize().toString()); // "/home/suchipi/Downloads"
   * ```
   */
  normalize(): Path;

  /**
   * Creates a new Path by appending additional path segments onto the end of
   * the target Path's segments.
   *
   * The returned Path will use the same separator as the target Path.
   *
   * **Example**
   * ```ts
   * const srcDir = new Path("/home/suchipi/my-project/src");
   * const indexFile = srcDir.concat("lib", "index.ts");
   * console.log(indexFile.toString()); // "/home/suchipi/my-project/src/lib/index.ts"
   * ```
   */
  concat(...other: Array<string | Path | Array<string | Path>>): Path;

  /**
   * Returns a boolean indicating whether the target Path is absolute; that
   * is, whether it starts with either a slash (`/` or `\`) or a drive letter
   * (ie `C:`).
   *
   * Note that Windows UNC Paths (eg. `\\MYSERVER\share$\`) are considered
   * absolute.
   *
   * **Example**
   * ```ts
   * let path = new Path("./src/index.ts");
   * if (!path.isAbsolute()) {
   *   path = pwd().concat(path).normalize();
   * }
   * console.log(path);
   * ```
   */
  isAbsolute(): boolean;

  /**
   * Creates a new Path object containing the same segments and separator as
   * the target Path.
   *
   * Note that although it contains the same segments, the new Path does not use
   * the same Array instance for segments as the target Path it was cloned from.
   *
   * **Example**
   * ```ts
   * const original = new Path("/usr/bin");
   * const cloned = original.clone();
   * cloned.segments.push("node");
   * console.log(original.toString(), cloned.toString()); // "/usr/bin", "/usr/bin/node"
   * ```
   */
  clone(): this;

  /**
   * Creates a new Path which expresses the target Path relative to `dir`.
   *
   * @param dir - The directory to create a new path relative to.
   * @param options - Options that affect the resulting path (see {@link PathRelativeToOptions}).
   *
   * **Example**
   * ```ts
   * const file = new Path("/home/suchipi/my-project/src/index.ts");
   * const relative = file.relativeTo("/home/suchipi/my-project");
   * console.log(relative.toString()); // "./src/index.ts"
   * ```
   */
  relativeTo(dir: Path | string, options?: PathRelativeToOptions): Path;

  /**
   * Turns the target Path into a string by joining its segments using its
   * separator as the delimiter.
   *
   * **Example**
   * ```ts
   * const path = new Path("/usr", "bin");
   * console.log("Installing to " + path.toString());
   * ```
   */
  toString(): string;

  /**
   * Alias for `toString`. The presence of this method causes Path objects to be
   * serialized as strings when they (or an object referencing them) get(s) passed
   * into JSON.stringify.
   *
   * **Example**
   * ```ts
   * const config = { outDir: new Path("/home/suchipi/my-project/dist") };
   * console.log(JSON.stringify(config)); // "{\"outDir\":\"/home/suchipi/my-project/dist\"}"
   * ```
   */
  toJSON(): string;

  /**
   * Returns the final segment of the target Path. If the target Path has no
   * segments, an empty string (`""`) is returned.
   *
   * **Example**
   * ```ts
   * const path = new Path("/home/suchipi/notes.txt");
   * console.log(path.basename()); // "notes.txt"
   * ```
   */
  basename(): string;

  /**
   * Returns the trailing file extension of this path.
   *
   * @param options - Works the same as the options parameter for the global {@link extname} (see {@link ExtnameOptions}).
   *
   * **Example**
   * ```ts
   * const path = new Path("src/types.d.ts");
   * console.log(path.extname(), path.extname({ full: true })); // ".ts", ".d.ts"
   * ```
   */
  extname(options?: ExtnameOptions): string;

  /**
   * Creates a new Path containing all of the segments in the target Path except
   * for the last one; ie. the path to the directory that contains the target Path.
   *
   * **Example**
   * ```ts
   * const path = new Path("/home/suchipi/notes.txt");
   * console.log(path.dirname().toString()); // "/home/suchipi"
   * ```
   */
  dirname(): Path;

  /**
   * Returns a boolean indicating whether the target Path starts with the
   * provided value, by comparing one path segment at a time.
   *
   * The starting segments of the target Path must *exactly* match the segments in the
   * provided value.
   *
   * This means that, given two Paths A and B:
   *
   * ```
   *   A: Path { /home/user/.config }
   *   B: Path { /home/user/.config2 }
   * ```
   *
   * Path B does *not* start with Path A, because `".config" !== ".config2"`.
   *
   * **Example**
   * ```ts
   * const path = new Path("/home/user/.config/app.toml");
   * console.log(path.startsWith("/home/user")); // true
   * ```
   */
  startsWith(value: string | Path | Array<string | Path>): boolean;

  /**
   * Returns a boolean indicating whether the target Path ends with the provided
   * value, by comparing one path segment at a time.
   *
   * The ending segments of the target Path must *exactly* match the segments in the
   * provided value.
   *
   * This means that, given two Paths A and B:
   *
   * ```
   *   A: Path { /home/1user/.config }
   *   B: Path { user/.config }
   * ```
   *
   * Path A does *not* end with Path B, because `"1user" !== "user"`.
   *
   * **Example**
   * ```ts
   * const path = new Path("/home/user/.config/app.toml");
   * console.log(path.endsWith(".config/app.toml")); // true
   * ```
   */
  endsWith(value: string | Path | Array<string | Path>): boolean;

  /**
   * Returns the index at which `value` appears in the target Path's segments,
   * or `-1` if `value` doesn't appear in the target Path.
   *
   * @param value - The value to search for. If the value contains more than one path segment, the returned index will refer to the location of the value's first path segment.
   * @param fromIndex - The index into the target Path's segments to begin searching at. Defaults to `0`.
   *
   * **Example**
   * ```ts
   * const path = new Path("/home/user/my-project/node_modules/kleur");
   * console.log(path.indexOf("node_modules")); // 4
   * ```
   */
  indexOf(
    value: string | Path | Array<string | Path>,
    fromIndex?: number | undefined,
  ): number;

  /**
   * Returns a boolean indicating whether `value` appears in the target Path.
   *
   * @param value - The value to search for.
   * @param fromIndex - The index into the target Path's segments to begin searching at. Defaults to `0`.
   *
   * **Example**
   * ```ts
   * const path = new Path("/home/user/my-project/node_modules/kleur");
   * if (path.includes("node_modules")) {
   *   console.log("This file belongs to a dependency");
   * }
   * ```
   */
  includes(
    value: string | Path | Array<string | Path>,
    fromIndex?: number | undefined,
  ): boolean;

  /**
   * Creates a new Path based on the target Path wherein the segments in `value`
   * have been replaced with the segments in `replacement`. If the segments in
   * `value` are not present in the target Path, a clone of the target Path is
   * returned.
   *
   * Note that only the first match is replaced. To replace more than one match,
   * use {@link Path.prototype.replaceAll}.
   *
   * @param value - What should be replaced
   * @param replacement - What it should be replaced with
   *
   * See also {@link Path.prototype.replaceLast}.
   *
   * **Example**
   * ```ts
   * const source = new Path("/my-project/src/utils/math.ts");
   * const output = source.replace("src", "dist");
   * console.log(output.toString()); // "/my-project/dist/utils/math.ts"
   * ```
   */
  replace(
    value: string | Path | Array<string | Path>,
    replacement: string | Path | Array<string | Path>,
  ): Path;

  /**
   * Creates a new Path based on the target Path wherein all occurrences of the
   * segments in `value` have been replaced with the segments in `replacement`.
   * If the segments in `value` are not present in the target Path, a clone of
   * the target Path is returned.
   *
   * Note that all matches are replaced. To replace only the first match,
   * use {@link Path.prototype.replace}.
   *
   * @param value - What should be replaced
   * @param replacement - What it should be replaced with
   *
   * See also {@link Path.prototype.replaceLast}.
   *
   * **Example**
   * ```ts
   * const path = new Path("/a/tmp/b/tmp/c");
   * console.log(path.replaceAll("tmp", "temp").toString()); // "/a/temp/b/temp/c"
   * ```
   */
  replaceAll(
    value: string | Path | Array<string | Path>,
    replacement: string | Path | Array<string | Path>,
  ): Path;

  /**
   * Creates a new Path based on the target Path but with the final segment
   * replaced with `replacement`.
   *
   * If the target Path has no segments, the newly created Path will be the same
   * as `new Path(replacement)`; ie. non-empty.
   *
   * @param replacement - The new final segment(s) for the returned Path
   *
   * **Example**
   * ```ts
   * const source = new Path("/my-project/src/index.ts");
   * const compiled = source.replaceLast("blah.js");
   * console.log(compiled.toString()); // "/my-project/src/blah.js"
   * ```
   */
  replaceLast(replacement: string | Path | Array<string | Path>): Path;

  /**
   * Return a boolean indicating whether this Path has the same separator and
   * segments as another Path.
   *
   * To check only segments and not separator, use {@link Path.prototype.hasEqualSegments}.
   *
   * **Example**
   * ```ts
   * const binDir = new Path("/usr/bin");
   * console.log(binDir.equals("/usr/bin")); // true
   * console.log(binDir.equals("/usr/local/bin")); // false
   * ```
   */
  equals(other: string | Path | Array<string | Path>): boolean;

  /**
   * Return a boolean indicating whether this Path has the same segments as
   * another Path. **Separator is not checked; use {@link Path.prototype.equals} for that.**
   *
   * **Example**
   * ```ts
   * const posixPath = new Path("src/index.ts");
   * const win32Path = new Path("src\\index.ts");
   * console.log(posixPath.hasEqualSegments(win32Path)); // false
   * ```
   */
  hasEqualSegments(other: string | Path | Array<string | Path>): boolean;
}

/**
 * Options for {@link Path.prototype.relativeTo}.
 *
 * **Example**
 * ```ts
 * const options: PathRelativeToOptions = { noLeadingDot: true };
 * const file = new Path("/my-project/src/index.ts");
 * console.log(file.relativeTo("/my-project", options).toString()); // "src/index.ts"
 * ```
 */
declare interface PathRelativeToOptions {
  /**
   * Defaults to false. When true, a leading `./` will be omitted from the
   * path, if present. Note that a leading `../` will never be omitted.
   *
   * **Example**
   * ```ts
   * const file = new Path("/my-project/src/index.ts");
   * const relative = file.relativeTo("/my-project", { noLeadingDot: true });
   * console.log(relative.toString()); // "src/index.ts"
   * ```
   */
  noLeadingDot?: boolean;
}

/**
 * Errors which can be thrown by {@link Path}'s methods/constructor.
 *
 * **Example**
 * ```ts
 * try {
 *   Path.normalize("/home/../..");
 * } catch (error) {
 *   if (error instanceof PathErrors.NormalizeGoingOutsideRootError) {
 *     console.error("That path goes above the filesystem root");
 *   }
 * }
 * ```
 */
declare namespace PathErrors {
  export class HolesInSegmentsError extends Error {}
  export class ZeroSegmentsError extends Error {}
  export class NormalizeGoingOutsideRootError extends Error {}
  export class RelativeToSelfError extends Error {}
}

/**
 * The absolute path to the currently-executing file (whether script or module).
 *
 * Behaves the same as in Node.js, except that it's also present within ES
 * modules.
 *
 * Example: `/home/suchipi/some-folder/some-file.js`
 */
declare var __filename: string;

/**
 * The absolute path to the directory containing the currently-executing file.
 *
 * Behaves the same as in Node.js, except that it's also present within ES
 * modules.
 *
 * Example: `/home/suchipi/some-folder`
 */
declare var __dirname: string;

/**
 * Return the last component of a path string.
 *
 * Provides the same functionality as the unix binary of the same name.
 *
 * > Example: `basename("/home/suchipi/something")` returns `"something"`, the last part.
 */
declare function basename(path: string | Path): string;

/**
 * Reads the contents of one or more files from disk as either one UTF-8 string
 * or one ArrayBuffer.
 *
 * Provides the same functionality as the unix binary of the same name.
 *
 * > Example: If you have a file called `hi.txt` in the current working
 * > directory, and it contains the text "hello", running `cat("hi.txt")`
 * > returns `"hello"`.
 */
declare const cat: {
  /**
   * Read the contents of one or more files from disk, as one UTF-8 string.
   *
   * **Example**
   * ```ts
   * const notes = cat("notes.txt");
   * console.log(notes.length);
   * ```
   */
  (paths: string | Path | Array<string | Path>): string;

  /**
   * Read the contents of one or more files from disk, as one UTF-8 string.
   *
   * **Example**
   * ```ts
   * const combined = cat(["README.md", "notes.txt"], {});
   * console.log(combined.length);
   * ```
   */
  (paths: string | Path | Array<string | Path>, options: {}): string;

  /**
   * Read the contents of one or more files from disk, as one UTF-8 string.
   *
   * **Example**
   * ```ts
   * const notes = cat("notes.txt", { binary: false });
   * console.log(notes.length);
   * ```
   */
  (
    paths: string | Path | Array<string | Path>,
    options: { binary: false },
  ): string;

  /**
   * Read the contents of one or more files from disk, as one ArrayBuffer.
   *
   * **Example**
   * ```ts
   * const bytes = cat("image.png", { binary: true });
   * console.log(bytes.byteLength);
   * ```
   */
  (
    paths: string | Path | Array<string | Path>,
    options: { binary: true },
  ): ArrayBuffer;
};

/**
 * Changes the process's current working directory to the specified path. If no
 * path is specified, moves to the user's home directory.
 *
 * Provides the same functionality as the shell builtin of the same name.
 *
 * **Example**
 * ```ts
 * cd("src");
 * console.log(pwd().toString());
 * ```
 */
declare function cd(path?: string | Path): void;

/**
 * Set the permission bits for the specified file.
 *
 * Provides the same functionality as the unix binary of the same name.
 *
 * **Example**
 * ```ts
 * chmod(0o755, "script.sh");
 * chmod("add", { user: "execute" }, "script.sh");
 * ```
 */
declare const chmod: Chmod;

/**
 * The interface for the global function `chmod`, which has two call signatures.
 *
 * **Example**
 * ```ts
 * const setPermissions: Chmod = chmod;
 * setPermissions("644", "notes.txt");
 * setPermissions("remove", { others: "read" }, "notes.txt");
 * ```
 */
interface Chmod {
  /**
   * Set the permission bits for the specified file.
   *
   * Provides the same functionality as the unix binary of the same name.
   *
   * @param permissions The permission bits to set. This can be a number, or a string containing an octal number.
   * @param path The path to the file.
   *
   * **Example**
   * ```ts
   * chmod(0o755, "script.sh");
   * chmod("644", "notes.txt");
   * ```
   */
  (permissions: number | string, path: string | Path): void;

  /**
   * Apply a change to the permission bits for the specified file.
   *
   * Provides the same functionality as the unix binary of the same name.
   *
   * @param operation What to do to the bits; can be "add", "set", or "remove".
   * @param permissions An object describing the changes (see below).
   * @param path The path to the file.
   *
   * Each of the `permissions` object's own property keys must be one of these
   * strings:
   *
   * - `"user"`
   * - `"group"`
   * - `"others"`
   * - `"all"` (meaning "user", "group", and "others")
   * - `"u"` (alias for "user")
   * - `"g"` (alias for "group")
   * - `"o"` (alias for "others")
   * - `"a"` (alias for "all")
   * - `"ug"` ("user" plus "group")
   * - `"go"` ("group" plus "others")
   * - `"uo"` ("user" plus "others")
   *
   * and their values must be one of these strings:
   *
   * - `"read"` (permission to read the contents of the file)
   * - `"write"` (permission to write to the file's contents)
   * - `"execute"` (permission to run the file as an executable)
   * - `"readwrite"` (both "read" and "write")
   * - `"none"` (no permissions)
   * - `"full"` ("read", "write", and "execute")
   * - `"r"` (alias for "read")
   * - `"w"` (alias for "write")
   * - `"x"` (alias for "execute")
   * - `"rw"` (alias for "readwrite")
   * - `"rx"` ("read" and "execute")
   * - `"wx"` ("write" and "execute")
   * - `"rwx"` (alias for "full")
   *
   * Some example objects:
   *
   * ```json
   * { user: "readwrite", group: "read", others: "none" }
   * { ug: "rw", o: "w" }
   * { all: "full" }
   * ```
   *
   * **Example**
   * ```ts
   * chmod("add", { user: "execute" }, "script.sh");
   * chmod("set", { ug: "rw", o: "r" }, "notes.txt");
   * ```
   */
  <Operation extends Chmod.Operation>(
    operation: Operation,
    permissions: Partial<Record<Chmod.Who, Chmod.Permission>>,
    path: string | Path,
  ): void;
}

declare namespace Chmod {
  /**
   * A string representing who a permission applies to.
   *
   * **Example**
   * ```ts
   * const who: Chmod.Who = "group";
   * chmod("add", { [who]: "write" }, "notes.txt");
   * ```
   */
  export type Who =
    | "user"
    | "group"
    | "others"
    | "all"
    | "u"
    | "g"
    | "o"
    | "a"
    | "ug"
    | "go"
    | "uo";

  /**
   * A string representing how the permissions should be changed.
   *
   * **Example**
   * ```ts
   * const operation: Chmod.Operation = "remove";
   * chmod(operation, { others: "read" }, "notes.txt");
   * ```
   */
  export type Operation = "add" | "set" | "remove";

  /**
   * A string representing the access level for the given permission.
   *
   * **Example**
   * ```ts
   * const permission: Chmod.Permission = "readwrite";
   * chmod("set", { user: permission }, "notes.txt");
   * ```
   */
  export type Permission =
    | "read"
    | "write"
    | "execute"
    | "readwrite"
    | "none"
    | "full"
    | "r"
    | "w"
    | "x"
    | "rw"
    | "rx"
    | "wx"
    | "rwx";
}

/**
 * Make a web request synchronously using the system libcurl library.
 *
 * Although most of yavascript is statically-linked, libcurl is not, because it
 * changes often and relies on your system's TLS libraries. To keep its
 * functionality secure and reliable, it's loaded dynamically on demand.
 *
 * On macOS, we attempt to load "libcurl.dylib". On Windows, we attempt to load
 * "libcurl.dll" or "libcurl-4.dll". On other platforms, we attempt to load
 * "libcurl.so.4" or "libcurl.so".
 *
 * To make a web request asynchronously, use curl within {@link runInWorker}.
 *
 * @param url - The web request url.
 * @param options - Request options. See {@link CurlOptions}.
 * @returns - A {@link CurlResponse} with the response data.
 */
declare function curl(url: string, options?: CurlOptions): CurlResponse;

/** Options for {@link curl}. */
declare type CurlOptions = {
  /**
   * HTTP request method. Defaults to "GET".
   *
   * Input values get uppercased.
   */
  method?: string;
  /** HTTP request body. */
  body?: string | ArrayBuffer | undefined;
  /** HTTP request headers. */
  headers?: Record<string, string | number | bigint>;
  /**
   * Redirect-following behavior. The default value is "follow", meaning
   * redirects will be followed.
   */
  redirect?: "follow" | "error" | "manual" | undefined;
};

/**
 * The response object returned by {@link curl}.
 *
 * Although it resembles the standard web `Response` object, note that its
 * methods aren't async (and neither is {@link curl}).
 */
declare class CurlResponse {
  /** The status code, eg. 200, 404, etc. */
  status: number;
  /**
   * The response headers, **with lowercase header names**.
   *
   * The value is an array of strings because headers such as "Set-Cookie" can
   * be specified more than once.
   */
  headers: {
    [name: string]: string[] | undefined;
  };
  /** A boolean indicating whether the status code is >= 200 and <= 299. */
  ok: boolean;

  /** Returns the response body as an ArrayBuffer. */
  arrayBuffer(): ArrayBuffer;
  /** Returns the response body as a Uint8Array. */
  bytes(): Uint8Array;
  /** Returns the response body as UTF-8 text passed through JSON.parse. */
  json(): unknown;
  /** Returns the response body as UTF-8 text. */
  text(): string;

  constructor(result: {
    status: number;
    response: ArrayBuffer;
    responseHeaders: {
      [name: string]: string[] | undefined;
    };
  });

  /** The raw response data. */
  protected _response: ArrayBuffer;
}

/**
 * Removes the final component from a path string.
 *
 * Provides the same functionality as the unix binary of the same name.
 *
 * > Example: `dirname("/home/suchipi/something")` returns
 * > `"/home/suchipi"`, everything except the last part.
 */
declare function dirname(path: string | Path): Path;

/**
 * Print one or more values to stdout.
 *
 * Provides the same functionality as the shell builtin of the same name.
 *
 * > NOTE: This can print any value, not just strings.
 *
 * `echo` is functionally identical to `console.log`.
 *
 * **Example**
 * ```ts
 * echo("hello", 42, { some: "object" });
 * ```
 */
declare const echo: typeof console.log;

/**
 * Exit the yavascript process.
 *
 * Provides the same functionality as the shell builtin of the same name.
 *
 * If exit is called with an argument, that argument is used as the exit code.
 * Otherwise, `exit.code` is used, which defaults to 0.
 *
 * `exit.code` will also be used as the exit status code for the yavascript
 * process if the process exits normally.
 *
 * > Attempting to call `exit` or set `exit.code` within a Worker will fail and
 * > throw an error.
 *
 * **Example**
 * ```ts
 * if (!exists("config.toml")) {
 *   console.error("config.toml is missing");
 *   exit(1);
 * }
 * exit.code = 2;
 * ```
 */
declare const exit: {
  (code?: number): never;
  code: number;
};

/**
 * Returns the file extension of the file at a given path.
 *
 * If the file has no extension (eg `Makefile`, etc), then `''` will be
 * returned.
 *
 * @param pathOrFilename The input path
 * @param options Options which affect the return value. See {@link ExtnameOptions}.
 *
 * **Example**
 * ```ts
 * const extension = extname("src/index.test.ts");
 * console.log(extension); // .ts
 * ```
 */
declare function extname(
  pathOrFilename: string | Path,
  options?: ExtnameOptions,
): string;

/**
 * Options for {@link extname} and {@link Path.prototype.extname}.
 *
 * **Example**
 * ```ts
 * const options: ExtnameOptions = { full: true };
 * console.log(extname("types.d.ts", options)); // .d.ts
 * ```
 */
declare interface ExtnameOptions {
  /**
   * Whether to get compound extensions, like `.d.ts` or `.test.js`, instead of
   * just the final extension (`.ts` or `.js` in this example).
   *
   * **Example**
   * ```ts
   * console.log(extname("types.d.ts", { full: true })); // .d.ts
   * console.log(extname("types.d.ts", { full: false })); // .ts
   * ```
   */
  full?: boolean;
}

/**
 * Returns the contents of a directory, sorted, as absolute paths. `.` and `..`
 * are omitted.
 *
 * If `ls()` is called with no directory, the present working directory
 * (`pwd()`) is used.
 *
 * **Example**
 * ```ts
 * for (const path of ls("src")) {
 *   console.log(path.basename());
 * }
 * ```
 */
declare function ls(dir?: string | Path): Array<Path>;

/**
 * Create a directory (folder).
 *
 * Provides the same functionality as the unix binary of the same name.
 *
 * **Example**
 * ```ts
 * mkdir("build");
 * mkdir("build/assets/images", { recursive: true });
 * ```
 */
declare function mkdir(
  path: string | Path,
  options?: {
    recursive?: boolean;
    mode?: number;
    logging?: {
      trace?: (...args: Array<any>) => void;
      info?: (...args: Array<any>) => void;
    };
  },
): void;

/**
 * Create a directory (folder) and all parents, recursively
 *
 * Alias for `mkdir(path, { recursive: true })`.
 *
 * Provides the same functionality as `mkdir -p`.
 *
 * **Example**
 * ```ts
 * mkdirp("build/assets/images");
 * ```
 */
declare function mkdirp(
  path: string | Path,
  options?: {
    mode?: number;
    logging?: {
      trace?: (...args: Array<any>) => void;
      info?: (...args: Array<any>) => void;
    };
  },
): void;

/**
 * Print data to stdout using C-style format specifiers.
 *
 * The same formats as the [standard C library
 * printf](https://en.cppreference.com/w/c/io/fprintf) are supported. Integer
 * format types (e.g. `%d`) truncate the Numbers or BigInts to 32 bits. Use the
 * l modifier (e.g. `%ld`) to truncate to 64 bits.
 *
 * **Example**
 * ```ts
 * printf("%s is %d years old\n", "Alice", 30);
 * ```
 */
declare function printf(format: string, ...args: Array<any>): void;

/**
 * Returns the process's current working directory.
 *
 * Provides the same functionality as the shell builtin of the same name.
 *
 * **Example**
 * ```ts
 * const here = pwd();
 * console.log(here);
 * ```
 */
declare const pwd: {
  /**
   * Returns the process's current working directory.
   *
   * Provides the same functionality as the shell builtin of the same name.
   *
   * **Example**
   * ```ts
   * const readmePath = pwd().concat("README.md");
   * console.log(readmePath);
   * ```
   */
  (): Path;

  /**
   * A frozen, read-only `Path` object containing what `pwd()` was when
   * yavascript first started up.
   *
   * **Example**
   * ```ts
   * cd("src");
   * cd(pwd.initial);
   * ```
   */
  readonly initial: Path;
};

/**
 * Reads a symlink.
 *
 * Returns the target of the symlink, which may be absolute or relative.
 *
 * Provides the same functionality as the unix binary of the same name.
 *
 * **Example**
 * ```ts
 * const target = readlink("link-to-readme");
 * console.log(target);
 * ```
 */
declare function readlink(path: string | Path): Path;

/**
 * Get the absolute path given a relative path. Symlinks are also resolved.
 *
 * The path's target file/directory must exist.
 *
 * Provides the same functionality as the unix binary of the same name.
 *
 * > If you want to convert a relative path to an absolute path, but the path's
 * > target might NOT exist, use {@link Path.normalize}.
 *
 * **Example**
 * ```ts
 * const absolutePath = realpath("./src/../README.md");
 * console.log(absolutePath);
 * ```
 */
declare function realpath(path: string | Path): Path;

/**
 * `sleep` and `sleep.sync` block the current thread for at least the specified
 * number of milliseconds, but maybe a tiny bit longer.
 *
 * `sleep.async` returns a Promise which resolves in at least the specified
 * number of milliseconds, but maybe a tiny bit longer.
 *
 * `sleep` and `sleep.sync` block the current thread. `sleep.async` doesn't
 * block the current thread.
 *
 * "Blocking the thread" means no other JavaScript code can run while `sleep` or
 * `sleep.sync` is running. If this is not the behavior you want, use
 * `sleep.async` instead.
 *
 * **Example**
 * ```ts
 * sleep(100);
 * sleep.sync(100);
 * await sleep.async(100);
 * ```
 */
declare var sleep: {
  /**
   * Blocks the current thread for at least the specified number of
   * milliseconds, but maybe a tiny bit longer.
   *
   * alias for `sleep.sync`.
   *
   * @param milliseconds - The number of milliseconds to block for.
   *
   * No other JavaScript code can run while `sleep()` is running. If this is
   * not the behavior you want, use `sleep.async` instead.
   *
   * **Example**
   * ```ts
   * console.log("waiting...");
   * sleep(500);
   * console.log("done");
   * ```
   */
  (milliseconds: number): void;

  /**
   * Blocks the current thread for at least the specified number of
   * milliseconds, but maybe a tiny bit longer.
   *
   * @param milliseconds - The number of milliseconds to block for.
   *
   * No other JavaScript code can run while `sleep.sync` is running. If this is
   * not the behavior you want, use `sleep.async` instead.
   *
   * **Example**
   * ```ts
   * while (!exists("server.pid")) {
   *   sleep.sync(100);
   * }
   * ```
   */
  sync(milliseconds: number): void;

  /**
   * Returns a Promise which resolves in at least the specified number of
   * milliseconds, maybe a little longer.
   *
   * @param milliseconds - The number of milliseconds to wait before the returned Promise should be resolved.
   *
   * `sleep.async` doesn't block the current thread, so other JavaScript code
   * (registered event handlers, async functions, timers, etc) can run while
   * `sleep.async`'s return Promise is waiting to resolve. If this is not the
   * behavior you want, use `sleep.sync` instead.
   *
   * If `milliseconds` isn't a finite number, the returned Promise gets
   * rejected with a TypeError.
   *
   * **Example**
   * ```ts
   * console.log("waiting...");
   * await sleep.async(500);
   * console.log("done");
   * ```
   */
  async(milliseconds: number): Promise<void>;
};

/**
 * If the file at `path` exists, update its creation/modification timestamps.
 *
 * Otherwise, create an empty file at that path.
 *
 * @param path The target path for the file.
 *
 * **Example**
 * ```ts
 * touch("build-finished.txt");
 * ```
 */
declare function touch(path: string | Path): void;

/**
 * Searches the system for the path to a program named `binaryName`.
 *
 * If the program can't be found, `null` is returned.
 *
 * @param binaryName The program to search for
 * @param options Options which affect how the search is performed
 * @param options.searchPaths A list of folders where programs may be found. Defaults to `env.PATH?.split(Path.OS_ENV_VAR_SEPARATOR) || []`.
 * @param options.suffixes A list of filename extension suffixes to include in the search, ie [".exe"]. Defaults to `Path.OS_PROGRAM_EXTENSIONS`.
 * @param options.trace A logging function that will be called at various times during the execution of `which`. Defaults to {@link logger.trace}.
 *
 * **Example**
 * ```ts
 * const gitPath = which("git");
 * if (gitPath == null) {
 *   throw new Error("git is not installed");
 * }
 * ```
 */
declare function which(binaryName: string, options?: WhichOptions): Path | null;

declare type WhichOptions = {
  /**
   * A list of folders where programs may be found. Defaults to
   * `env.PATH?.split(Path.OS_ENV_VAR_SEPARATOR) || []`.
   *
   * **Example**
   * ```ts
   * const tool = which("my-tool", {
   *   searchPaths: ["./bin", "/usr/local/bin"],
   * });
   * ```
   */
  searchPaths?: Array<Path | string>;

  /**
   * A list of filename extension suffixes to include in the search, ie
   * `[".exe"]`. Defaults to {@link Path.OS_PROGRAM_EXTENSIONS}.
   *
   * **Example**
   * ```ts
   * const node = which("node", { suffixes: [".exe", ".cmd"] });
   * ```
   */
  suffixes?: Array<string>;

  /**
   * Options which control logging.
   *
   * **Example**
   * ```ts
   * which("git", { logging: { trace: console.error } });
   * ```
   */
  logging?: {
    /**
     * If provided, this logging function will be called multiple times as
     * `which` runs, to help you understand what's going on and/or troubleshoot
     * things. In most cases, it makes sense to use a function from `console`
     * here, like so:
     *
     * ```js
     * which("bash", {
     *   logging: { trace: console.log }
     * });
     * ```
     *
     * Defaults to the current value of {@link logger.trace}. `logger.trace`
     * defaults to a no-op function.
     */
    trace?: (...args: Array<any>) => void;
  };
};

/**
 * The type of the return value of {@link whoami}.
 *
 * **Example**
 * ```ts
 * const user: WhoAmIResult = whoami();
 * console.log(user.name, user.uid, user.gid);
 * ```
 */
declare interface WhoAmIResult {
  name: string;
  uid: number;
  gid: number;
}

/**
 * Get info about the user the yavascript process is executing as.
 *
 * Provides functionality similar to the unix binaries `whoami` and `id`.
 *
 * NOTE: Doesn't work on Windows; throws an error.
 *
 * **Example**
 * ```ts
 * const { name } = whoami();
 * console.log(`Running as ${name}`);
 * ```
 */
declare function whoami(): WhoAmIResult;


/**
 * Runs a child process and blocks until it exits. You can call it with either a
 * string or an array of strings.
 *
 * When calling `exec` with an array of strings, the first string in the array
 * is the program to run, and the rest of the strings in the array are arguments
 * to the program, eg:
 *
 * ```ts
 * exec(["echo", "hi", "there"]);
 * exec(["printf", "something with spaces\n"]);
 * ```
 *
 * When calling with a string instead of an array, the string will be split into
 * separate arguments using the following rules:
 *
 * - The program and its arguments will be determined by splitting the input
 *   string on whitespace, except:
 *   - Stuff in single or double-quotes will be preserved as a single argument
 *   - Double and single quotes can be "glued" together (eg `"bla"'bla'` becomes
 *     `blabla`)
 *   - The escape sequences `\n`, `\r`, `\t`, `\v`, `\0`, and `\\` can be used
 *     inside of quotes get replaced with newline, carriage return, tab,
 *     vertical tab, nul, and `\` characters, respectively
 *
 * For example:
 *
 * ```ts
 * exec(`echo hi there`);
 * exec(`printf "something with spaces\n"`);
 * ```
 *
 * The intent is that it behaves similarly to what you would expect from a UNIX
 * shell, but only the "safe" features. "Unsafe" features like environment
 * variable expansion (`$VAR` or `${VAR}`), subshells (\`echo hi\` or `$(echo
 * hi)`), and redirection (`> /dev/null` or `2>&1 `) are not supported. To use
 * those features, shell out to `bash` or `sh` directly via eg `exec(['bash',
 * '-c', 'your command string'])`, but be aware of the security implications of
 * doing so.
 *
 * `exec` also supports a second argument, an options object which supports the
 * following keys (all are optional):
 *
 * | Property                       | Purpose                                             |
 * | ------------------------------ | --------------------------------------------------- |
 * | cwd (string)                   | current working directory for the child process     |
 * | env (object)                   | environment variables for the process               |
 * | failOnNonZeroStatus (boolean)  | whether to throw error on nonzero exit status       |
 * | captureOutput (boolean/string) | controls how stdout/stderr is directed              |
 * | logging (object)               | controls how/whether info messages are logged       |
 * | block (boolean)                | whether to wait for child process exit now or later |
 *
 * The return value of `exec` varies depending on the options passed:
 *
 * - When `captureOutput` is true or "utf-8", an object will be returned with
 *   `stdout` and `stderr` properties, both strings.
 * - When `captureOutput` is "arraybuffer", an object will be returned with
 *   `stdout` and `stderr` properties, both `ArrayBuffer`s.
 * - When `failOnNonZeroStatus` is false, an object will be returned with
 *   `status` (the exit code; number or undefined) and `signal` (the signal that
 *   killed the process; number or undefined).
 * - When `captureOutput` is non-false and `failOnNonZeroStatus` is false, an
 *   object will be returned with four properties (the two associated with
 *   `failOnNonZeroStatus`, and the two associated with `captureOutput`).
 * - When `captureOutput` is false or unspecified, and `failOnNonZeroStatus` is
 *   true or unspecified, undefined will be returned.
 * - If `block` is false, an object with a "wait" method is returned instead,
 *   which blocks the calling thread until the process exits, and then returns
 *   one of the values described above.
 */
declare const exec: Exec;

declare type BaseExecOptions = {
  /**
   * Sets the current working directory for the child process.
   *
   * **Example**
   * ```ts
   * exec("ls -la", { cwd: "src" });
   * ```
   */
  cwd?: string | Path;

  /**
   * Sets environment variables within the process.
   *
   * **Example**
   * ```ts
   * exec(["printenv", "GREETING"], { env: { GREETING: "hello" } });
   * ```
   */
  env?: { [key: string | number]: string | number | boolean };

  /**
   * Options which control logging.
   *
   * **Example**
   * ```ts
   * exec("echo hi", {
   *   logging: { trace: console.error, info: console.error },
   * });
   * ```
   */
  logging?: {
    /**
     * If provided, this logging function will be called multiple times as
     * `exec` runs, to help you understand what's going on and/or troubleshoot
     * things. In most cases, it makes sense to use a function from `console`
     * here, like so:
     *
     * ```js
     * exec(["echo", "hi"], {
     *   logging: { trace: console.log },
     * });
     * ```
     *
     * Defaults to the current value of {@link logger.trace}. `logger.trace`
     * defaults to a no-op function.
     */
    trace?: (...args: Array<any>) => void;

    /**
     * An optional, user-provided logging function to be used for informational
     * messages. Less verbose than `logging.trace`.
     *
     * Defaults to the current value of {@link logger.info}. `logger.info`
     * defaults to a function which logs to stderr.
     *
     * **Example**
     * ```ts
     * const info = (...args: Array<any>) => console.error("[exec]", ...args);
     * exec("echo hi", { logging: { info } });
     * ```
     */
    info?: (...args: Array<any>) => void;
  };

  /**
   * Whether an Error should be thrown when the process exits with a nonzero
   * status code.
   *
   * Defaults to true.
   *
   * **Example**
   * ```ts
   * const result = exec("git diff --quiet", { failOnNonZeroStatus: false });
   * if (result.status !== 0) {
   *   console.log("There are unstaged changes");
   * }
   * ```
   */
  failOnNonZeroStatus?: boolean;

  /**
   * If true, stdout and stderr will be collected into strings or array buffers
   * and returned instead of being printed to the screen.
   *
   * Defaults to false. true is an alias for "utf8".
   *
   * **Example**
   * ```ts
   * const { stdout } = exec("git rev-parse HEAD", { captureOutput: true });
   * console.log(stdout.trim());
   * ```
   */
  captureOutput?: boolean | "utf8" | "arraybuffer";

  /**
   * If true, exec doesn't return until the process is done running. If false,
   * exec returns an object with a "wait" method which can be used to wait for
   * the process to be done running.
   *
   * Defaults to true.
   *
   * **Example**
   * ```ts
   * const child = exec("sleep 1", { block: false });
   * console.log("this prints while the child process is still running");
   * child.wait();
   * ```
   */
  block?: boolean;
};

declare interface Exec {
  /**
   * Runs a child process using the provided arguments.
   *
   * When `args` is an Array, the first value in the Array is the program to
   * run.
   *
   * @param args - The command to run.
   * @param options - Options; see {@link BaseExecOptions}
   *
   * **Example**
   * ```ts
   * exec(["git", "status", "--short"]);
   * exec("git status --short", { cwd: "src" });
   * ```
   */
  <
    ExecOptions extends BaseExecOptions = {
      failOnNonZeroStatus: true;
      captureOutput: false;
      block: true;
    },
  >(
    args: Array<string | Path | number> | string | Path,
    options?: ExecOptions,
  ): ExecOptions["block"] extends false
    ? { wait(): ExecWaitResult<ExecOptions> }
    : ExecWaitResult<ExecOptions>;

  /**
   * Parse the provided value into an array of command-line argument strings,
   * using the same logic that {@link exec} and {@link ChildProcess} use.
   *
   * **Example**
   * ```ts
   * const argv = exec.toArgv(`git commit -m "initial commit"`);
   * console.log(argv); // ["git", "commit", "-m", "initial commit"]
   * ```
   */
  toArgv(args: Array<string | Path | number> | string | Path): Array<string>;
}

/**
 * `$(...)` is an alias for `exec(..., { captureOutput: true, failOnNonZeroStatus: true })`.
 *
 * It's often used to capture the output of a program:
 *
 * ```ts
 * const result = $(`echo hi`).stdout;
 * // result is 'hi\n'
 * ```
 *
 * For more info, see {@link exec}.
 */
declare function $(args: Array<string | Path | number> | string | Path): {
  stdout: string;
  stderr: string;
};

type ExecWaitResult<ExecOptions extends BaseExecOptions> = ExecOptions extends
  | { captureOutput: true | "utf8" | "arraybuffer" }
  | { failOnNonZeroStatus: false }
  ? (ExecOptions["captureOutput"] extends true | "utf8"
      ? { stdout: string; stderr: string }
      : {}) &
      (ExecOptions["captureOutput"] extends "arraybuffer"
        ? { stdout: ArrayBuffer; stderr: ArrayBuffer }
        : {}) &
      (ExecOptions["failOnNonZeroStatus"] extends false
        ? | { status: number; signal: undefined }
          | { status: undefined; signal: number }
        : {})
  : void;

/**
 * A class which represents a child process. The process may or may not be
 * running.
 *
 * This class is the API used internally by the {@link exec} function to spawn child
 * processes.
 *
 * Generally, you should not need to use the `ChildProcess` class directly, and
 * should use {@link exec} or {@link $} instead. However, you may need to use it in some
 * special cases, like when specifying custom stdio for a process, or spawning a
 * non-blocking long-running process.
 *
 * **Example**
 * ```ts
 * const child = new ChildProcess(["echo", "hi"]);
 * child.start();
 * child.waitUntilComplete();
 * ```
 */
declare interface ChildProcess {
  /**
   * The argv for the process. The first entry in this array is the program to
   * run.
   *
   * **Example**
   * ```ts
   * const child = new ChildProcess("echo hi there");
   * console.log(child.args);
   * ```
   */
  args: Array<string>;

  /**
   * The current working directory for the process.
   *
   * **Example**
   * ```ts
   * const child = new ChildProcess(["ls"], { cwd: "src" });
   * console.log(child.cwd.toString());
   * ```
   */
  cwd: Path;

  /**
   * The environment variables for the process.
   *
   * **Example**
   * ```ts
   * const child = new ChildProcess(["printenv", "GREETING"]);
   * child.env.GREETING = "hello";
   * child.start();
   * child.waitUntilComplete();
   * ```
   */
  env: { [key: string]: string };

  /**
   * The standard I/O streams for the process. Generally these are the same as
   * `std.in`, `std.out`, and `std.err`, but they can be customized to write
   * output elsewhere.
   *
   * **Example**
   * ```ts
   * const logFile = std.open("output.log", "w");
   * const child = new ChildProcess(["echo", "hi"]);
   * child.stdio.out = logFile;
   * child.stdio.err = logFile;
   * child.start();
   * child.waitUntilComplete();
   * logFile.close();
   * ```
   */
  stdio: {
    /**
     * Where the process reads stdin from
     *
     * **Example**
     * ```ts
     * const child = new ChildProcess(["cat"]);
     * child.stdio.in = std.open("notes.txt", "r");
     * child.start();
     * child.waitUntilComplete();
     * ```
     */
    in: FILE;
    /**
     * Where the process writes stdout to
     *
     * **Example**
     * ```ts
     * const child = new ChildProcess(["date"]);
     * child.stdio.out = std.open("date.txt", "w");
     * child.start();
     * child.waitUntilComplete();
     * ```
     */
    out: FILE;
    /**
     * Where the process writes stderr to
     *
     * **Example**
     * ```ts
     * const child = new ChildProcess(["ls", "does-not-exist"]);
     * child.stdio.err = std.open("errors.log", "w");
     * child.start();
     * child.waitUntilComplete();
     * ```
     */
    err: FILE;
  };

  get state(): ChildProcessState;
  get pid(): number | null;

  /**
   * Spawns the process and returns its pid (process id).
   *
   * **Example**
   * ```ts
   * const child = new ChildProcess(["sleep", "1"]);
   * const pid = child.start();
   * console.log(pid);
   * ```
   */
  start(): number;

  /**
   * Blocks the calling thread until the process exits or is killed.
   *
   * **Example**
   * ```ts
   * const child = new ChildProcess(["sleep", "1"]);
   * child.start();
   * const { status, signal } = child.waitUntilComplete();
   * console.log(status, signal);
   * ```
   */
  waitUntilComplete():
    | { status: number; signal: undefined }
    | { status: undefined; signal: number };
}

declare type ChildProcessState =
  | {
      id: "UNSTARTED";
    }
  | {
      id: "STARTED";
      pid: number;
    }
  | {
      id: "STOPPED";
      pid: number;
    }
  | {
      id: "CONTINUED";
      pid: number;
    }
  | {
      id: "EXITED";
      oldPid: number;
      status: number;
    }
  | {
      id: "SIGNALED";
      oldPid: number;
      signal: number;
    };

/**
 * Options to be passed to the ChildProcess constructor. Their purposes and
 * types match the same-named properties found on the resulting ChildProcess.
 *
 * **Example**
 * ```ts
 * const options: ChildProcessOptions = {
 *   cwd: "src",
 *   env: { GREETING: "hello" },
 * };
 * const child = new ChildProcess(["printenv", "GREETING"], options);
 * ```
 */
declare type ChildProcessOptions = {
  /**
   * The current working directory for the process.
   *
   * **Example**
   * ```ts
   * const child = new ChildProcess(["ls"], { cwd: "src" });
   * child.start();
   * child.waitUntilComplete();
   * ```
   */
  cwd?: string | Path;

  /**
   * The environment variables for the process.
   *
   * **Example**
   * ```ts
   * const child = new ChildProcess(["printenv", "GREETING"], {
   *   env: { GREETING: "hello" },
   * });
   * child.start();
   * child.waitUntilComplete();
   * ```
   */
  env?: { [key: string]: string };

  /**
   * The standard I/O streams for the process. Generally these are the same as
   * `std.in`, `std.out`, and `std.err`, but they can be customized to write
   * output elsewhere.
   *
   * **Example**
   * ```ts
   * const logFile = std.open("output.log", "w");
   * const child = new ChildProcess(["echo", "hi"], {
   *   stdio: { out: logFile, err: logFile },
   * });
   * child.start();
   * child.waitUntilComplete();
   * logFile.close();
   * ```
   */
  stdio?: {
    /**
     * Where the process reads stdin from
     *
     * **Example**
     * ```ts
     * const child = new ChildProcess(["cat"], {
     *   stdio: { in: std.open("notes.txt", "r") },
     * });
     * child.start();
     * child.waitUntilComplete();
     * ```
     */
    in?: FILE;
    /**
     * Where the process writes stdout to
     *
     * **Example**
     * ```ts
     * const child = new ChildProcess(["date"], {
     *   stdio: { out: std.open("date.txt", "w") },
     * });
     * child.start();
     * child.waitUntilComplete();
     * ```
     */
    out?: FILE;
    /**
     * Where the process writes stderr to
     *
     * **Example**
     * ```ts
     * const child = new ChildProcess(["ls", "does-not-exist"], {
     *   stdio: { err: std.open("errors.log", "w") },
     * });
     * child.start();
     * child.waitUntilComplete();
     * ```
     */
    err?: FILE;
  };

  /**
   * Options which control logging
   *
   * **Example**
   * ```ts
   * const child = new ChildProcess(["echo", "hi"], {
   *   logging: { trace: console.error },
   * });
   * ```
   */
  logging?: {
    /**
     * Optional trace function which, if present, will be called at various
     * times to provide information about the lifecycle of the process.
     *
     * Defaults to the current value of {@link logger.trace}. `logger.trace`
     * defaults to a function which writes to stderr.
     *
     * **Example**
     * ```ts
     * const child = new ChildProcess(["echo", "hi"], {
     *   logging: { trace: (...args) => console.error("[child]", ...args) },
     * });
     * child.start();
     * child.waitUntilComplete();
     * ```
     */
    trace?: (...args: Array<any>) => void;
  };
};

declare interface ChildProcessConstructor {
  /**
   * Construct a new ChildProcess.
   *
   * @param args - The argv for the process. The first entry in this array is the program to run.
   * @param options - Options for the process (cwd, env, stdio, etc)
   *
   * **Example**
   * ```ts
   * const child = new ChildProcess(["ls", "-la"], { cwd: "src" });
   * child.start();
   * child.waitUntilComplete();
   * ```
   */
  new (
    args: string | Path | Array<string | number | Path>,
    options?: ChildProcessOptions,
  ): ChildProcess;

  readonly prototype: ChildProcess;
}

declare var ChildProcess: ChildProcessConstructor;

/**
 * Searches the filesystem in order to resolve [UNIX-style glob
 * strings](https://man7.org/linux/man-pages/man7/glob.7.html) into an array of
 * matching filesystem paths.
 *
 * Glob strings assist in succinctly finding and describing a set of files on
 * disk. For instance, to find the path of every `.js` file in the `src` folder,
 * one might write `src/*.js`.
 *
 * The function `glob` can be used to turn one or more of these "glob strings" into an array of
 * `Path` objects.
 *
 * `glob` uses [minimatch](https://www.npmjs.com/package/minimatch) with its
 * default options, which means it supports features like brace expanstion,
 * "globstar" (**) matching, and other features you would expect from a modern
 * globbing solution.
 *
 * > When specifying more than one pattern string, paths must match ALL of the
 * > patterns to be included in the returned Array. In other words, it uses
 * > "logical AND" behavior when you give it more than one pattern.
 *
 * **Example**
 * ```ts
 * const markdownFiles = glob("*.md");
 * const sources = glob(["src/*.ts", "!src/*.d.ts"]);
 * console.log(markdownFiles, sources);
 * ```
 */
declare function glob(
  patterns: string | Array<string>,
  options?: GlobOptions,
): Array<Path>;

/**
 * Options for {@link glob}.
 *
 * **Example**
 * ```ts
 * const options: GlobOptions = {
 *   dir: pwd().concat("src"),
 *   followSymlinks: true,
 * };
 * const files = glob("*.ts", options);
 * ```
 */
declare type GlobOptions = {
  /**
   * Whether to treat symlinks to directories as if they themselves were
   * directories, traversing into them.
   *
   * Defaults to false.
   *
   * **Example**
   * ```ts
   * const files = glob("*.md", { followSymlinks: true });
   * ```
   */
  followSymlinks?: boolean;

  /**
   * Options which control logging.
   *
   * **Example**
   * ```ts
   * glob("src/*.ts", {
   *   logging: { trace: console.error, info: console.error },
   * });
   * ```
   */
  logging?: {
    /**
     * If provided, this function will be called multiple times as `glob`
     * traverses the filesystem, to help you understand what's going on and/or
     * troubleshoot things. In most cases, it makes sense to use a logging
     * function here, like so:
     *
     * ```js
     * glob(["./*.js"], {
     *  logging: { trace: console.log }
     * });
     * ```
     *
     * Defaults to the current value of {@link logger.trace}. `logger.trace`
     * defaults to a no-op function.
     */
    trace?: (...args: Array<any>) => void;

    /**
     * An optional, user-provided logging function to be used for informational
     * messages. Less verbose than `logging.trace`.
     *
     * Defaults to the current value of {@link logger.info}. `logger.info`
     * defaults to a function which writes to stderr.
     *
     * **Example**
     * ```ts
     * glob("src/*.ts", {
     *   logging: { info: (...args) => console.error("[glob]", ...args) },
     * });
     * ```
     */
    info?: (...args: Array<any>) => void;
  };

  /**
   * Directory to interpret glob patterns relative to. Must be an absolute
   * path. Defaults to `pwd()`.
   *
   * **Example**
   * ```ts
   * const files = glob("*.ts", { dir: pwd().concat("src") });
   * ```
   */
  dir?: string | Path;
};

/**
 * Prints special ANSI escape characters to stdout which instruct your terminal
 * emulator to clear the screen and clear your terminal scrollback.
 *
 * Identical to {@link console.clear}.
 *
 * **Example**
 * ```ts
 * clear();
 * ```
 */
declare function clear(): void;

interface Console {
  /**
   * Logs its arguments to stdout, with a newline appended.
   *
   * Any value can be logged, not just strings. Non-string values will be
   * formatted using {@link inspect}.
   *
   * Functionally identical to {@link console.info}, {@link echo}, and
   * {@link print}. Contrast with {@link console.error}, which prints to stderr
   * instead of stdout.
   *
   * **Example**
   * ```ts
   * console.log("hello", 42, { some: "object" });
   * ```
   */
  log(message?: any, ...optionalParams: any[]): void;

  /**
   * Logs its arguments to stdout, with a newline appended.
   *
   * Any value can be logged, not just strings. Non-string values will be
   * formatted using {@link inspect}.
   *
   * Functionally identical to {@link console.log}, {@link echo}, and
   * {@link print}. Contrast with {@link console.error}, which prints to stderr
   * instead of stdout.
   *
   * **Example**
   * ```ts
   * console.info("Build finished in", 12, "seconds");
   * ```
   */
  info(message?: any, ...optionalParams: any[]): void;

  /**
   * Logs its arguments to stderr, with a newline appended.
   *
   * Any value can be logged, not just strings. Non-string values will be
   * formatted using {@link inspect}.
   *
   * Functionally identical to {@link console.error}. Contrast with
   * {@link console.log}, which prints to stdout instead of stderr.
   *
   * **Example**
   * ```ts
   * console.warn("config.toml not found; using defaults");
   * ```
   */
  warn(message?: any, ...optionalParams: any[]): void;

  /**
   * Logs its arguments to stderr, with a newline appended.
   *
   * Any value can be logged, not just strings. Non-string values will be
   * formatted using {@link inspect}.
   *
   * Functionally identical to {@link console.warn}. Contrast with
   * {@link console.log}, which prints to stdout instead of stderr.
   *
   * **Example**
   * ```ts
   * console.error("Something went wrong:", new Error("oh no"));
   * ```
   */
  error(message?: any, ...optionalParams: any[]): void;

  /**
   * Prints special ANSI escape characters to stdout which instruct your terminal
   * emulator to clear the screen and clear your terminal scrollback.
   *
   * Identical to {@link clear}.
   *
   * **Example**
   * ```ts
   * console.clear();

   * ```
   */
  clear(): void;
}

declare var console: Console;

/**
 * `print` is an alias for {@link console.log}, which prints values to stdout.
 *
 * Any value can be logged, not just strings. Non-string values will be
 * formatted using {@link inspect}.
 *
 * **Example**
 * ```ts
 * print("hello", [1, 2, 3]);
 * ```
 */
declare function print(...args: any): void;

/**
 * Removes ANSI control characters from a string.
 *
 * **Example**
 * ```ts
 * const plain = stripAnsi(red("error"));
 * console.log(plain.length);
 * ```
 */
declare function stripAnsi(input: string | number | Path): string;

/**
 * Wraps a string in double quotes, and escapes any double-quotes inside using `\"`.
 *
 * **Example**
 * ```ts
 * console.log(quote('She said "hi"'));
 * ```
 */
declare function quote(input: string | number | Path): string;

// Colors

/**
 * Wraps a string with the ANSI control characters that will make it print as black text.
 *
 * **Example**
 * ```ts
 * console.log(bgWhite(black("dark text on a light background")));
 * ```
 */
declare function black(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it print as red text.
 *
 * **Example**
 * ```ts
 * console.error(red("Error: file not found"));
 * ```
 */
declare function red(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it print as green text.
 *
 * **Example**
 * ```ts
 * console.log(green("All tests passed"));
 * ```
 */
declare function green(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it print as yellow text.
 *
 * **Example**
 * ```ts
 * console.warn(yellow("Warning: config file is missing"));
 * ```
 */
declare function yellow(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it print as blue text.
 *
 * **Example**
 * ```ts
 * console.log(blue("Downloading dependencies..."));
 * ```
 */
declare function blue(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it print as magenta text.
 *
 * **Example**
 * ```ts
 * console.log(magenta("Deploying to production"));
 * ```
 */
declare function magenta(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it print as cyan text.
 *
 * **Example**
 * ```ts
 * console.log(cyan("https://example.com"));
 * ```
 */
declare function cyan(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it print as white text.
 *
 * **Example**
 * ```ts
 * console.log(bgBlue(white("light text on a dark background")));
 * ```
 */
declare function white(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it print as gray text. (Alias for {@link grey}.)
 *
 * **Example**
 * ```ts
 * console.log(gray("(skipped 3 files)"));
 * ```
 */
declare function gray(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it print as grey text. (Alias for {@link gray}.)
 *
 * **Example**
 * ```ts
 * console.log(grey("(skipped 3 files)"));
 * ```
 */
declare function grey(input: string | number | Path): string;

// Background Colors

/**
 * Wraps a string with the ANSI control characters that will make it have a black background when printed.
 *
 * **Example**
 * ```ts
 * console.log(bgBlack(white(" README.md ")));
 * ```
 */
declare function bgBlack(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it have a red background when printed.
 *
 * **Example**
 * ```ts
 * console.log(bgRed(" FAIL "), "tests/math.test.ts");
 * ```
 */
declare function bgRed(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it have a green background when printed.
 *
 * **Example**
 * ```ts
 * console.log(bgGreen(" PASS "), "tests/math.test.ts");
 * ```
 */
declare function bgGreen(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it have a yellow background when printed.
 *
 * **Example**
 * ```ts
 * console.log(bgYellow(black(" WARN ")), "deprecated option");
 * ```
 */
declare function bgYellow(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it have a blue background when printed.
 *
 * **Example**
 * ```ts
 * console.log(bgBlue(" INFO "), "server started");
 * ```
 */
declare function bgBlue(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it have a magenta background when printed.
 *
 * **Example**
 * ```ts
 * console.log(bgMagenta(" DEBUG "), "cache miss");
 * ```
 */
declare function bgMagenta(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it have a cyan background when printed.
 *
 * **Example**
 * ```ts
 * console.log(bgCyan(black(" NOTE ")), "using default config");
 * ```
 */
declare function bgCyan(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it have a white background when printed.
 *
 * **Example**
 * ```ts
 * console.log(bgWhite(black(" v1.0.0 ")));
 * ```
 */
declare function bgWhite(input: string | number | Path): string;

// Modifiers

/**
 * Prefixes a string with the ANSI control character that resets all styling.
 *
 * **Example**
 * ```ts
 * console.log(reset("plain text with no styling"));
 * ```
 */
declare function reset(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it print with a bold style.
 *
 * **Example**
 * ```ts
 * console.log(bold("Important:"), "read this first");
 * ```
 */
declare function bold(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it print with a dimmed style.
 *
 * **Example**
 * ```ts
 * console.log(dim("last updated 3 days ago"));
 * ```
 */
declare function dim(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it print italicized.
 *
 * **Example**
 * ```ts
 * console.log(italic("emphasis"));
 * ```
 */
declare function italic(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it print underlined.
 *
 * **Example**
 * ```ts
 * console.log(underline("https://example.com"));
 * ```
 */
declare function underline(input: string | number | Path): string;

/**
 * Wraps a string with ANSI control characters that will make it print with its foreground (text) and background colors swapped.
 *
 * **Example**
 * ```ts
 * console.log(inverse(" selected item "));
 * ```
 */
declare function inverse(input: string | number | Path): string;

/**
 * Wraps a string with ANSI control characters that will make it print as hidden.
 *
 * **Example**
 * ```ts
 * console.log("password:", hidden("hunter2"));
 * ```
 */
declare function hidden(input: string | number | Path): string;

/**
 * Wraps a string with the ANSI control characters that will make it print with a horizontal line through its center.
 *
 * **Example**
 * ```ts
 * console.log(strikethrough("buy milk"));
 * ```
 */
declare function strikethrough(input: string | number | Path): string;

/**
 * Splits the string passed into it on `\n` and then returns the lines matching
 * the specified pattern, as an array of strings or detail objects.
 *
 * @param str - The string to search through.
 * @param pattern - The pattern to find. Can be a string or a RegExp.
 * @param options - Options which control matching behavior.
 *
 * See also {@link grepFile}, {@link grepArray}, {@link String.prototype.grep},
 * and {@link Array.prototype.grep}.
 *
 * **Example**
 * ```ts
 * const lines = grepString("apple\nbanana\ncherry", /an/);
 * console.log(lines); // ["banana"]
 * ```
 */
declare const grepString: {
  (
    str: string,
    pattern: string | RegExp,
    options: GrepOptions & { details: true },
  ): Array<GrepMatchDetail>;

  (str: string, pattern: string | RegExp, options?: GrepOptions): Array<string>;
};

/**
 * Returns those Array items matching the specified pattern, as either an
 * Array of items or an Array of detail objects.
 *
 * @param targetArray - The Array of strings to search through. Non-strings will be coerced to string during matching.
 * @param pattern - The pattern to find. Can be a string or a RegExp.
 * @param options - Options which control matching behavior.
 *
 * See also {@link grepString}, {@link grepFile}, {@link String.prototype.grep},
 * and {@link Array.prototype.grep}.
 *
 * **Example**
 * ```ts
 * const matches = grepArray(["apple", "banana", "cherry"], "an");
 * console.log(matches); // ["banana"]
 * ```
 */
declare const grepArray: {
  <T>(
    targetArray: Array<T>,
    pattern: string | RegExp,
    options: GrepOptions & { details: true },
  ): Array<GrepMatchDetail<T>>;

  <T>(
    targetArray: Array<T>,
    pattern: string | RegExp,
    options?: GrepOptions,
  ): Array<T>;
};

/**
 * Reads the file content at `path`, splits it on `\n`, and then returns the
 * lines matching the specified pattern, as an array of strings or detail
 * objects.
 *
 * @param path - The path to the file to search through.
 * @param pattern - The pattern to find. Can be a string or a RegExp.
 * @param options - Options which control matching behavior.
 *
 * See also {@link grepArray}, {@link grepString},
 * {@link String.prototype.grep}, and {@link Array.prototype.grep}.
 *
 * **Example**
 * ```ts
 * const todos = grepFile("README.md", /TODO/);
 * console.log(todos);
 * ```
 */
declare const grepFile: {
  (
    path: string | Path,
    pattern: string | RegExp,
    options: GrepOptions & { details: true },
  ): Array<GrepMatchDetail>;

  (
    path: string | Path,
    pattern: string | RegExp,
    options?: GrepOptions,
  ): Array<string>;
};

interface String {
  // Same as grepString but without the first argument.
  /**
   * Splits the target string on `\n` and then returns the lines matching the
   * specified pattern, as an array of strings or detail objects.
   *
   * @param str - The string to search through.
   * @param pattern - The pattern to find. Can be a string or a RegExp.
   * @param options - Options which control matching behavior.
   *
   * See also {@link grepString}, {@link grepArray}, {@link grepFile}, and
   * {@link Array.prototype.grep}.
   *
   * **Example**
   * ```ts
   * const lines = "apple\nbanana\ncherry".grep(/an/);
   * console.log(lines); // ["banana"]
   * ```
   */
  grep: {
    (
      pattern: string | RegExp,
      options: GrepOptions & { details: true },
    ): Array<GrepMatchDetail>;

    (pattern: string | RegExp, options?: GrepOptions): Array<string>;
  };
}

interface Array<T> {
  // Same as grepArray but without the first argument.
  /**
   * Returns those Array items matching the specified pattern, as either an
   * Array of items or an Array of detail objects.
   *
   * @param pattern - The pattern to find. Can be a string or a RegExp.
   * @param options - Options which control matching behavior.
   *
   * See also {@link grepString}, {@link grepArray}, {@link grepFile}, and
   * {@link String.prototype.grep}.
   *
   * **Example**
   * ```ts
   * const matches = ["apple", "banana", "cherry"].grep(/an/);
   * console.log(matches); // ["banana"]
   * ```
   */
  grep: {
    (
      pattern: string | RegExp,
      options: GrepOptions & { details: true },
    ): Array<GrepMatchDetail<T>>;

    (pattern: string | RegExp, options?: GrepOptions): Array<T>;
  };
}

declare interface GrepOptions {
  /**
   * When `inverse` is true, the grep function returns those lines which DON'T
   * match the pattern, instead of those which do. Defaults to `false`.
   *
   * **Example**
   * ```ts
   * const fruits = "apple\nbanana\ncherry";
   * const nonMatching = grepString(fruits, /an/, { inverse: true });
   * console.log(nonMatching); // ["apple", "cherry"]
   * ```
   */
  inverse?: boolean;

  /**
   * When `details` is true, the grep function returns an array of
   * {@link GrepMatchDetail} objects instead of an array of strings. Defaults to
   * `false`.
   *
   * **Example**
   * ```ts
   * const fruits = "apple\nbanana\ncherry";
   * const details = grepString(fruits, /an/, { details: true });
   * console.log(details[0].lineNumber, details[0].lineContent);
   * ```
   */
  details?: boolean;
}

/**
 * When `grepString`, `grepArray`, `grepFile`, or `String.prototype.grep` are
 * called with the `{ details: true }` option set, an Array of `GrepMatchDetail`
 * objects is returned.
 *
 * **Example**
 * ```ts
 * const [detail] = grepString("apple\nbanana", /an/, { details: true });
 * console.log(detail.lineNumber, detail.lineContent, detail.matches);
 * ```
 */
declare interface GrepMatchDetail<ItemType = string> {
  lineNumber: number;
  lineContent: ItemType;
  matches: RegExpMatchArray;

  /**
   * Same as lineNumber - 1.
   *
   * **Example**
   * ```ts
   * const [detail] = grepString("apple\nbanana", /an/, { details: true });
   * console.log(detail.index === detail.lineNumber - 1);
   * ```
   */
  index: number;
  /**
   * Alias for lineContent.
   *
   * **Example**
   * ```ts
   * const [detail] = grepString("apple\nbanana", /an/, { details: true });
   * console.log(detail.content === detail.lineContent);
   * ```
   */
  content: ItemType;
}

/**
 * The `types` namespace object contains various functions which can be used to
 * identify the type of a value at runtime. It is based on
 * [pheno](https://github.com/suchipi/pheno), with some yavascript-specific
 * extensions.
 *
 * ## Usage
 *
 * To check that a value is of a type, use `is`. To assert that a value is of a
 * type, use `assert.type`:
 *
 * ```ts
 * is("hi", types.string); // true
 * is("hi", types.number); // false
 * is({ blah: 42 }, types.objectWithProperties({ blah: types.number })); // true
 *
 * assert.type("hi", types.string);
 * assert.type("hi", types.number); // throws
 * assert.type({ blah: 42 }, types.objectWithProperties({ blah: types.number }));
 * ```
 *
 * In many cases, you can use a "normal" JavaScript value for the type instead
 * of something from the `types` namespace. For instance, the following code
 * block is equivalent to the previous one:
 *
 * ```ts
 * is("hi", String); // true
 * is("hi", Number); // false
 * is({ blah: 42 }, { blah: Number }); // true
 *
 * assert.type("hi", String);
 * assert.type("hi", Number); // throws
 * assert.type({ blah: 42 }, { blah: Number });
 * ```
 *
 * For more info about using "normal" values, see the "Coercion" heading below.
 *
 * ## Explanation
 *
 * There are two kinds of function properties found on the `types` namespace:
 * those which return a boolean, and those which return a function. Functions
 * which return a boolean are called "type validators", and can be used to check
 * the type of a value. For example, `types.number` is a type validator:
 *
 * ```ts
 * is(42, types.number); // returns true
 * ```
 *
 * The other kind of function is a function which returns a function. These are
 * called "type validator constructors", because the function they return is a
 * type validator. They are used to construct complex type validators. For
 * example, `types.exactString` is a type validator constructor:
 *
 * ```ts
 * const myType = types.exactString("potato");
 * // myType is a function which returns true or false
 *
 * is("eggplant", myType); // returns false
 * is("potato", myType); // returns true
 * ```
 *
 * ## List of Functions
 *
 * ### Type Validators
 *
 * Here is a list of all the type validators:
 *
 * - `any`
 * - `anyArray`
 * - `anyFunction`
 * - `anyMap`
 * - `anyObject`
 * - `anySet`
 * - `anyTypeValidator`
 * - `array` (alias of `arrayOfUnknown`)
 * - `arrayOfAny`
 * - `arrayOfUnknown`
 * - `Array` (alias of `arrayOfUnknown`)
 * - `bigint`
 * - `BigInt` (alias of `bigint`)
 * - `boolean`
 * - `Boolean` (alias of `boolean`)
 * - `Date`
 * - `Error`
 * - `false`
 * - `falsy`
 * - `Function` (alias of `unknownFunction`)
 * - `Infinity`
 * - `integer`
 * - `map` (alias of `unknownMap`)
 * - `Map` (alias of `unknownMap`)
 * - `NaN`
 * - `NegativeInfinity`
 * - `never`
 * - `nonNullOrUndefined`
 * - `null`
 * - `nullish`
 * - `void` (alias of `nullish`)
 * - `number` (doesn't include NaN, Infinity, or -Infinity)
 * - `Number` (alias of `number`)
 * - `numberIncludingNanAndInfinities`
 * - `object` (alias of `unknownObject`)
 * - `Object` (alias of `unknownObject`)
 * - `objectOrNull`
 * - `RegExp`
 * - `set` (alias of `unknownSet`)
 * - `Set` (alias of `unknownSet`)
 * - `string`
 * - `String` (alias of `string`)
 * - `Symbol`
 * - `symbol` (alias of `Symbol`)
 * - `true`
 * - `truthy`
 * - `undefined`
 * - `unknown`
 * - `unknownFunction`
 * - `unknownMap`
 * - `unknownObject`
 * - `unknownSet`
 * - `unknownTypeValidator`
 * - `ArrayBuffer`
 * - `SharedArrayBuffer`
 * - `DataView`
 * - `TypedArray`
 * - `Int8Array`
 * - `Uint8Array`
 * - `Uint8ClampedArray`
 * - `Int16Array`
 * - `Uint16Array`
 * - `Int32Array`
 * - `Uint32Array`
 * - `Float32Array`
 * - `Float64Array`
 * - `FILE`
 * - `Path`
 * - `JSX.Element` (alias of `JSX.unknownElement`)
 * - `JSX.unknownElement`
 * - `JSX.anyElement`
 * - `JSX.Fragment`
 *
 * ### Type Validator Constructors
 *
 * And all the type validator constructors:
 *
 * - `and`
 * - `arrayOf`
 * - `exactBigInt`
 * - `exactNumber`
 * - `exactString`
 * - `exactSymbol`
 * - `hasClassName`
 * - `hasToStringTag`
 * - `instanceOf`
 * - `intersection`
 * - `mapOf`
 * - `mappingObjectOf`
 * - `maybe`
 * - `objectWithOnlyTheseProperties`
 * - `objectWithProperties`
 * - `or`
 * - `optional`
 * - `partialObjectWithProperties`
 * - `record`
 * - `setOf`
 * - `stringMatching`
 * - `symbolFor`
 * - `union`
 *
 * ## Coercion
 *
 * There is also a function, `types.coerce`, which returns an appropriate type
 * validator value for a given input value, using the following logic:
 *
 * | Input value                   | Output validator                   |
 * | ----------------------------- | ---------------------------------- |
 * | `String` or `string` global   | `types.string`                     |
 * | `Number` or `number` global   | `types.number`                     |
 * | `Boolean` or `boolean` global | `types.boolean`                    |
 * | `BigInt` or `bigint` global   | `types.bigint`                     |
 * | `Symbol` global               | `types.Symbol`                     |
 * | `RegExp` global               | `types.RegExp`                     |
 * | `Array` global                | `types.arrayOfUnknown`             |
 * | `Set` global                  | `types.unknownSet`                 |
 * | `Map` global                  | `types.unknownMap`                 |
 * | `Object` global               | `types.unknownObject`              |
 * | `Date` global                 | `types.Date`                       |
 * | `Function` global             | `types.unknownFunction`            |
 * | `ArrayBuffer` global          | `types.ArrayBuffer`                |
 * | `SharedArrayBuffer` global    | `types.SharedArrayBuffer`          |
 * | `DataView` global             | `types.DataView`                   |
 * | `Int8Array` global            | `types.Int8Array`                  |
 * | `Uint8Array` global           | `types.Uint8Array`                 |
 * | `Uint8ClampedArray` global    | `types.Uint8ClampedArray`          |
 * | `Int16Array` global           | `types.Int16Array`                 |
 * | `Uint16Array` global          | `types.Uint16Array`                |
 * | `Int32Array` global           | `types.Int32Array`                 |
 * | `Uint32Array` global          | `types.Uint32Array`                |
 * | `Float32Array` global         | `types.Float32Array`               |
 * | `Float64Array` global         | `types.Float64Array`               |
 * | `Path` global                 | `types.Path`                       |
 * | Any RegExp value              | Validator for matching strings     |
 * | Empty array                   | Validator for empty arrays         |
 * | Array with one item           | Validator for array of that item   |
 * | Array with multiple items     | Validator for tuple of those types |
 * | Class constructor function    | Validator for instances of it      |
 * | Any Object value              | Validator for same-shaped object   |
 * | null                          | `types.null`                       |
 * | undefined                     | `types.undefined`                  |
 * | true                          | `types.true`                       |
 * | false                         | `types.false`                      |
 * | NaN                           | `types.NaN`                        |
 * | Infinity                      | `types.Infinity`                   |
 * | `-Infinity`                   | `types.NegativeInfinity`           |
 * | Any string value              | `types.exactString(<the value>)`   |
 * | Any 'normal' number value     | `types.exactNumber(<the value>)`   |
 * | Any Symbol value              | `types.exactSymbol(<the value>)`   |
 * | Any BigInt value              | `types.exactBigInt(<the value>)`   |
 *
 * > All type constructors, as well as `is` and `assert.type`, do coercion
 * > automatically! This means that in many cases, you do not need to access
 * > properties from the `types` namespace.
 */
declare const types: {
  // basic types
  any: TypeValidator<any>;
  unknown: TypeValidator<unknown>;
  anyObject: TypeValidator<{
    [key: string | number | symbol]: any;
  }>;
  unknownObject: TypeValidator<{}>;
  object: TypeValidator<{}>;
  Object: TypeValidator<{}>;
  arrayOfAny: TypeValidator<Array<any>>;
  arrayOfUnknown: TypeValidator<Array<unknown>>;
  array: TypeValidator<Array<unknown>>;
  Array: TypeValidator<unknown[]>;
  anyArray: TypeValidator<Array<any>>;
  boolean: TypeValidator<boolean>;
  Boolean: TypeValidator<boolean>;
  string: TypeValidator<string>;
  String: TypeValidator<string>;
  null: TypeValidator<null>;
  undefined: TypeValidator<undefined>;
  nullish: TypeValidator<null | undefined>;
  void: TypeValidator<null | undefined>;
  numberIncludingNanAndInfinities: TypeValidator<number>;
  number: TypeValidator<number>;
  Number: TypeValidator<number>;
  NaN: TypeValidator<number>;
  Infinity: TypeValidator<number>;
  NegativeInfinity: TypeValidator<number>;
  integer: TypeValidator<number>;
  bigint: TypeValidator<bigint>;
  BigInt: TypeValidator<bigint>;
  never: TypeValidator<never>;
  anyFunction: TypeValidator<(...args: any) => any>;
  unknownFunction: TypeValidator<(...args: Array<unknown>) => unknown>;
  Function: TypeValidator<(...args: Array<unknown>) => unknown>;
  false: TypeValidator<false>;
  true: TypeValidator<true>;
  falsy: TypeValidator<false | null | undefined | "" | 0>;
  truthy: <T>(target: false | "" | 0 | T | null | undefined) => target is T;
  nonNullOrUndefined: <T>(target: T | null | undefined) => target is T;
  Error: TypeValidator<Error>;
  Symbol: TypeValidator<symbol>;
  symbol: TypeValidator<symbol>;
  RegExp: TypeValidator<RegExp>;
  Date: TypeValidator<Date>;
  anyMap: TypeValidator<Map<any, any>>;
  unknownMap: TypeValidator<Map<unknown, unknown>>;
  map: TypeValidator<Map<unknown, unknown>>;
  Map: TypeValidator<Map<unknown, unknown>>;
  anySet: TypeValidator<Set<any>>;
  unknownSet: TypeValidator<Set<unknown>>;
  set: TypeValidator<Set<unknown>>;
  Set: TypeValidator<Set<unknown>>;
  ArrayBuffer: TypeValidator<ArrayBuffer>;
  SharedArrayBuffer: TypeValidator<SharedArrayBuffer>;
  DataView: TypeValidator<DataView>;
  TypedArray: TypeValidator<
    | Int8Array
    | Uint8Array
    | Uint8ClampedArray
    | Int16Array
    | Uint16Array
    | Int32Array
    | Uint32Array
    | Float32Array
    | Float64Array
  >;
  Int8Array: TypeValidator<Int8Array>;
  Uint8Array: TypeValidator<Uint8Array>;
  Uint8ClampedArray: TypeValidator<Uint8ClampedArray>;
  Int16Array: TypeValidator<Int16Array>;
  Uint16Array: TypeValidator<Uint16Array>;
  Int32Array: TypeValidator<Int32Array>;
  Uint32Array: TypeValidator<Uint32Array>;
  Float32Array: TypeValidator<Float32Array>;
  Float64Array: TypeValidator<Float64Array>;

  // type constructors
  exactString<T extends string>(str: T): TypeValidator<T>;
  exactNumber<T extends number>(num: T): TypeValidator<T>;
  exactBigInt<T extends bigint>(num: T): TypeValidator<T>;
  exactSymbol<T extends symbol>(sym: T): TypeValidator<T>;
  hasClassName<Name extends string>(
    name: Name,
  ): TypeValidator<{ constructor: Function & { name: Name } }>;
  hasToStringTag(name: string): TypeValidator<any>;
  instanceOf<Klass extends Function & { prototype: any }>(
    klass: Klass,
  ): TypeValidator<Klass["prototype"]>;
  stringMatching(regexp: RegExp): TypeValidator<string>;
  symbolFor(key: string): TypeValidator<symbol>;
  arrayOf<T extends TypeValidator<any> | CoerceableToTypeValidator | unknown>(
    typeValidator: T,
  ): TypeValidator<Array<UnwrapTypeFromCoerceableOrValidator<T>>>;
  intersection: {
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third> &
        UnwrapTypeFromCoerceableOrValidator<Fourth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third> &
        UnwrapTypeFromCoerceableOrValidator<Fourth> &
        UnwrapTypeFromCoerceableOrValidator<Fifth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third> &
        UnwrapTypeFromCoerceableOrValidator<Fourth> &
        UnwrapTypeFromCoerceableOrValidator<Fifth> &
        UnwrapTypeFromCoerceableOrValidator<Sixth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third> &
        UnwrapTypeFromCoerceableOrValidator<Fourth> &
        UnwrapTypeFromCoerceableOrValidator<Fifth> &
        UnwrapTypeFromCoerceableOrValidator<Sixth> &
        UnwrapTypeFromCoerceableOrValidator<Seventh>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third> &
        UnwrapTypeFromCoerceableOrValidator<Fourth> &
        UnwrapTypeFromCoerceableOrValidator<Fifth> &
        UnwrapTypeFromCoerceableOrValidator<Sixth> &
        UnwrapTypeFromCoerceableOrValidator<Seventh> &
        UnwrapTypeFromCoerceableOrValidator<Eighth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
      ninth: Ninth,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third> &
        UnwrapTypeFromCoerceableOrValidator<Fourth> &
        UnwrapTypeFromCoerceableOrValidator<Fifth> &
        UnwrapTypeFromCoerceableOrValidator<Sixth> &
        UnwrapTypeFromCoerceableOrValidator<Seventh> &
        UnwrapTypeFromCoerceableOrValidator<Eighth> &
        UnwrapTypeFromCoerceableOrValidator<Ninth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Tenth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
      ninth: Ninth,
      tenth: Tenth,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third> &
        UnwrapTypeFromCoerceableOrValidator<Fourth> &
        UnwrapTypeFromCoerceableOrValidator<Fifth> &
        UnwrapTypeFromCoerceableOrValidator<Sixth> &
        UnwrapTypeFromCoerceableOrValidator<Seventh> &
        UnwrapTypeFromCoerceableOrValidator<Eighth> &
        UnwrapTypeFromCoerceableOrValidator<Ninth> &
        UnwrapTypeFromCoerceableOrValidator<Tenth>
    >;
  };
  and: {
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third> &
        UnwrapTypeFromCoerceableOrValidator<Fourth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third> &
        UnwrapTypeFromCoerceableOrValidator<Fourth> &
        UnwrapTypeFromCoerceableOrValidator<Fifth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third> &
        UnwrapTypeFromCoerceableOrValidator<Fourth> &
        UnwrapTypeFromCoerceableOrValidator<Fifth> &
        UnwrapTypeFromCoerceableOrValidator<Sixth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third> &
        UnwrapTypeFromCoerceableOrValidator<Fourth> &
        UnwrapTypeFromCoerceableOrValidator<Fifth> &
        UnwrapTypeFromCoerceableOrValidator<Sixth> &
        UnwrapTypeFromCoerceableOrValidator<Seventh>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third> &
        UnwrapTypeFromCoerceableOrValidator<Fourth> &
        UnwrapTypeFromCoerceableOrValidator<Fifth> &
        UnwrapTypeFromCoerceableOrValidator<Sixth> &
        UnwrapTypeFromCoerceableOrValidator<Seventh> &
        UnwrapTypeFromCoerceableOrValidator<Eighth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
      ninth: Ninth,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third> &
        UnwrapTypeFromCoerceableOrValidator<Fourth> &
        UnwrapTypeFromCoerceableOrValidator<Fifth> &
        UnwrapTypeFromCoerceableOrValidator<Sixth> &
        UnwrapTypeFromCoerceableOrValidator<Seventh> &
        UnwrapTypeFromCoerceableOrValidator<Eighth> &
        UnwrapTypeFromCoerceableOrValidator<Ninth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Tenth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
      ninth: Ninth,
      tenth: Tenth,
    ): TypeValidator<
      UnwrapTypeFromCoerceableOrValidator<First> &
        UnwrapTypeFromCoerceableOrValidator<Second> &
        UnwrapTypeFromCoerceableOrValidator<Third> &
        UnwrapTypeFromCoerceableOrValidator<Fourth> &
        UnwrapTypeFromCoerceableOrValidator<Fifth> &
        UnwrapTypeFromCoerceableOrValidator<Sixth> &
        UnwrapTypeFromCoerceableOrValidator<Seventh> &
        UnwrapTypeFromCoerceableOrValidator<Eighth> &
        UnwrapTypeFromCoerceableOrValidator<Ninth> &
        UnwrapTypeFromCoerceableOrValidator<Tenth>
    >;
  };
  union: {
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
      | UnwrapTypeFromCoerceableOrValidator<Fourth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
      | UnwrapTypeFromCoerceableOrValidator<Fourth>
      | UnwrapTypeFromCoerceableOrValidator<Fifth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
      | UnwrapTypeFromCoerceableOrValidator<Fourth>
      | UnwrapTypeFromCoerceableOrValidator<Fifth>
      | UnwrapTypeFromCoerceableOrValidator<Sixth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
      | UnwrapTypeFromCoerceableOrValidator<Fourth>
      | UnwrapTypeFromCoerceableOrValidator<Fifth>
      | UnwrapTypeFromCoerceableOrValidator<Sixth>
      | UnwrapTypeFromCoerceableOrValidator<Seventh>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
      | UnwrapTypeFromCoerceableOrValidator<Fourth>
      | UnwrapTypeFromCoerceableOrValidator<Fifth>
      | UnwrapTypeFromCoerceableOrValidator<Sixth>
      | UnwrapTypeFromCoerceableOrValidator<Seventh>
      | UnwrapTypeFromCoerceableOrValidator<Eighth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
      ninth: Ninth,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
      | UnwrapTypeFromCoerceableOrValidator<Fourth>
      | UnwrapTypeFromCoerceableOrValidator<Fifth>
      | UnwrapTypeFromCoerceableOrValidator<Sixth>
      | UnwrapTypeFromCoerceableOrValidator<Seventh>
      | UnwrapTypeFromCoerceableOrValidator<Eighth>
      | UnwrapTypeFromCoerceableOrValidator<Ninth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Tenth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
      ninth: Ninth,
      tenth: Tenth,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
      | UnwrapTypeFromCoerceableOrValidator<Fourth>
      | UnwrapTypeFromCoerceableOrValidator<Fifth>
      | UnwrapTypeFromCoerceableOrValidator<Sixth>
      | UnwrapTypeFromCoerceableOrValidator<Seventh>
      | UnwrapTypeFromCoerceableOrValidator<Eighth>
      | UnwrapTypeFromCoerceableOrValidator<Ninth>
      | UnwrapTypeFromCoerceableOrValidator<Tenth>
    >;
  };
  or: {
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
      | UnwrapTypeFromCoerceableOrValidator<Fourth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
      | UnwrapTypeFromCoerceableOrValidator<Fourth>
      | UnwrapTypeFromCoerceableOrValidator<Fifth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
      | UnwrapTypeFromCoerceableOrValidator<Fourth>
      | UnwrapTypeFromCoerceableOrValidator<Fifth>
      | UnwrapTypeFromCoerceableOrValidator<Sixth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
      | UnwrapTypeFromCoerceableOrValidator<Fourth>
      | UnwrapTypeFromCoerceableOrValidator<Fifth>
      | UnwrapTypeFromCoerceableOrValidator<Sixth>
      | UnwrapTypeFromCoerceableOrValidator<Seventh>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
      | UnwrapTypeFromCoerceableOrValidator<Fourth>
      | UnwrapTypeFromCoerceableOrValidator<Fifth>
      | UnwrapTypeFromCoerceableOrValidator<Sixth>
      | UnwrapTypeFromCoerceableOrValidator<Seventh>
      | UnwrapTypeFromCoerceableOrValidator<Eighth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
      ninth: Ninth,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
      | UnwrapTypeFromCoerceableOrValidator<Fourth>
      | UnwrapTypeFromCoerceableOrValidator<Fifth>
      | UnwrapTypeFromCoerceableOrValidator<Sixth>
      | UnwrapTypeFromCoerceableOrValidator<Seventh>
      | UnwrapTypeFromCoerceableOrValidator<Eighth>
      | UnwrapTypeFromCoerceableOrValidator<Ninth>
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Tenth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
      ninth: Ninth,
      tenth: Tenth,
    ): TypeValidator<
      | UnwrapTypeFromCoerceableOrValidator<First>
      | UnwrapTypeFromCoerceableOrValidator<Second>
      | UnwrapTypeFromCoerceableOrValidator<Third>
      | UnwrapTypeFromCoerceableOrValidator<Fourth>
      | UnwrapTypeFromCoerceableOrValidator<Fifth>
      | UnwrapTypeFromCoerceableOrValidator<Sixth>
      | UnwrapTypeFromCoerceableOrValidator<Seventh>
      | UnwrapTypeFromCoerceableOrValidator<Eighth>
      | UnwrapTypeFromCoerceableOrValidator<Ninth>
      | UnwrapTypeFromCoerceableOrValidator<Tenth>
    >;
  };
  mapOf<
    K extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    V extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
  >(
    keyType: K,
    valueType: V,
  ): TypeValidator<
    Map<
      UnwrapTypeFromCoerceableOrValidator<K>,
      UnwrapTypeFromCoerceableOrValidator<V>
    >
  >;
  setOf<T extends TypeValidator<any> | CoerceableToTypeValidator | unknown>(
    itemType: T,
  ): TypeValidator<Set<UnwrapTypeFromCoerceableOrValidator<T>>>;
  maybe<T extends TypeValidator<any> | CoerceableToTypeValidator | unknown>(
    itemType: T,
  ): TypeValidator<UnwrapTypeFromCoerceableOrValidator<T> | undefined | null>;
  objectWithProperties<
    T extends {
      [key: string | number | symbol]:
        | TypeValidator<any>
        | CoerceableToTypeValidator
        | unknown;
    },
  >(
    properties: T,
  ): TypeValidator<{
    [key in keyof T]: UnwrapTypeFromCoerceableOrValidator<T[key]>;
  }>;
  objectWithOnlyTheseProperties<
    T extends {
      [key: string | number | symbol]:
        | TypeValidator<any>
        | CoerceableToTypeValidator
        | unknown;
    },
  >(
    properties: T,
  ): TypeValidator<{
    [key in keyof T]: UnwrapTypeFromCoerceableOrValidator<T[key]>;
  }>;

  mappingObjectOf<
    Values extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    Keys extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
  >(
    keyType: Keys,
    valueType: Values,
  ): TypeValidator<
    Record<
      UnwrapTypeFromCoerceableOrValidator<Keys> extends string | number | symbol
        ? UnwrapTypeFromCoerceableOrValidator<Keys>
        : never,
      UnwrapTypeFromCoerceableOrValidator<Values>
    >
  >;
  record<
    Values extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    Keys extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
  >(
    keyType: Keys,
    valueType: Values,
  ): TypeValidator<
    Record<
      UnwrapTypeFromCoerceableOrValidator<Keys> extends string | number | symbol
        ? UnwrapTypeFromCoerceableOrValidator<Keys>
        : never,
      UnwrapTypeFromCoerceableOrValidator<Values>
    >
  >;
  partialObjectWithProperties<
    T extends {
      [key: string | number | symbol]:
        | TypeValidator<any>
        | CoerceableToTypeValidator
        | unknown;
    },
  >(
    properties: T,
  ): TypeValidator<{
    [key in keyof T]:
      | UnwrapTypeFromCoerceableOrValidator<T[key]>
      | null
      | undefined;
  }>;
  tuple: {
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
    ): TypeValidator<
      [
        UnwrapTypeFromCoerceableOrValidator<First>,
        UnwrapTypeFromCoerceableOrValidator<Second>,
      ]
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
    ): TypeValidator<
      [
        UnwrapTypeFromCoerceableOrValidator<First>,
        UnwrapTypeFromCoerceableOrValidator<Second>,
        UnwrapTypeFromCoerceableOrValidator<Third>,
      ]
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
    ): TypeValidator<
      [
        UnwrapTypeFromCoerceableOrValidator<First>,
        UnwrapTypeFromCoerceableOrValidator<Second>,
        UnwrapTypeFromCoerceableOrValidator<Third>,
        UnwrapTypeFromCoerceableOrValidator<Fourth>,
      ]
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
    ): TypeValidator<
      [
        UnwrapTypeFromCoerceableOrValidator<First>,
        UnwrapTypeFromCoerceableOrValidator<Second>,
        UnwrapTypeFromCoerceableOrValidator<Third>,
        UnwrapTypeFromCoerceableOrValidator<Fourth>,
        UnwrapTypeFromCoerceableOrValidator<Fifth>,
      ]
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
    ): TypeValidator<
      [
        UnwrapTypeFromCoerceableOrValidator<First>,
        UnwrapTypeFromCoerceableOrValidator<Second>,
        UnwrapTypeFromCoerceableOrValidator<Third>,
        UnwrapTypeFromCoerceableOrValidator<Fourth>,
        UnwrapTypeFromCoerceableOrValidator<Fifth>,
        UnwrapTypeFromCoerceableOrValidator<Sixth>,
      ]
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
    ): TypeValidator<
      [
        UnwrapTypeFromCoerceableOrValidator<First>,
        UnwrapTypeFromCoerceableOrValidator<Second>,
        UnwrapTypeFromCoerceableOrValidator<Third>,
        UnwrapTypeFromCoerceableOrValidator<Fourth>,
        UnwrapTypeFromCoerceableOrValidator<Fifth>,
        UnwrapTypeFromCoerceableOrValidator<Sixth>,
        UnwrapTypeFromCoerceableOrValidator<Seventh>,
      ]
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
    ): TypeValidator<
      [
        UnwrapTypeFromCoerceableOrValidator<First>,
        UnwrapTypeFromCoerceableOrValidator<Second>,
        UnwrapTypeFromCoerceableOrValidator<Third>,
        UnwrapTypeFromCoerceableOrValidator<Fourth>,
        UnwrapTypeFromCoerceableOrValidator<Fifth>,
        UnwrapTypeFromCoerceableOrValidator<Sixth>,
        UnwrapTypeFromCoerceableOrValidator<Seventh>,
        UnwrapTypeFromCoerceableOrValidator<Eighth>,
      ]
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
      ninth: Ninth,
    ): TypeValidator<
      [
        UnwrapTypeFromCoerceableOrValidator<First>,
        UnwrapTypeFromCoerceableOrValidator<Second>,
        UnwrapTypeFromCoerceableOrValidator<Third>,
        UnwrapTypeFromCoerceableOrValidator<Fourth>,
        UnwrapTypeFromCoerceableOrValidator<Fifth>,
        UnwrapTypeFromCoerceableOrValidator<Sixth>,
        UnwrapTypeFromCoerceableOrValidator<Seventh>,
        UnwrapTypeFromCoerceableOrValidator<Eighth>,
        UnwrapTypeFromCoerceableOrValidator<Ninth>,
      ]
    >;
    <
      First extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Second extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Third extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fourth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Fifth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Sixth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Seventh extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Eighth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Ninth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
      Tenth extends TypeValidator<any> | CoerceableToTypeValidator | unknown,
    >(
      first: First,
      second: Second,
      third: Third,
      fourth: Fourth,
      fifth: Fifth,
      sixth: Sixth,
      seventh: Seventh,
      eighth: Eighth,
      ninth: Ninth,
      tenth: Tenth,
    ): TypeValidator<
      [
        UnwrapTypeFromCoerceableOrValidator<First>,
        UnwrapTypeFromCoerceableOrValidator<Second>,
        UnwrapTypeFromCoerceableOrValidator<Third>,
        UnwrapTypeFromCoerceableOrValidator<Fourth>,
        UnwrapTypeFromCoerceableOrValidator<Fifth>,
        UnwrapTypeFromCoerceableOrValidator<Sixth>,
        UnwrapTypeFromCoerceableOrValidator<Seventh>,
        UnwrapTypeFromCoerceableOrValidator<Eighth>,
        UnwrapTypeFromCoerceableOrValidator<Ninth>,
        UnwrapTypeFromCoerceableOrValidator<Tenth>,
      ]
    >;
  };

  coerce: <V extends CoerceableToTypeValidator | TypeValidator<any> | unknown>(
    value: V,
  ) => TypeValidator<UnwrapTypeFromCoerceableOrValidator<V>>;

  FILE: TypeValidator<FILE>;
  Path: TypeValidator<Path>;
  JSX: {
    unknownElement: TypeValidator<
      JSX.Element<{ [key: string | symbol | number]: unknown }, unknown>
    >;
    anyElement: TypeValidator<JSX.Element<any, any>>;
    Element: TypeValidator<
      JSX.Element<{ [key: string | symbol | number]: unknown }, unknown>
    >;
    Fragment: TypeValidator<JSX.Fragment>;
  };
};

declare type TypeValidator<T> = (value: any) => value is T;

declare type CoerceToTypeValidator<V extends CoerceableToTypeValidator> =
  V extends StringConstructor
    ? TypeValidator<string>
    : V extends NumberConstructor
      ? TypeValidator<number>
      : V extends BooleanConstructor
        ? TypeValidator<boolean>
        : V extends BigIntConstructor
          ? TypeValidator<BigInt>
          : V extends SymbolConstructor
            ? TypeValidator<Symbol>
            : V extends RegExpConstructor
              ? TypeValidator<RegExp>
              : V extends ArrayConstructor
                ? TypeValidator<Array<unknown>>
                : V extends SetConstructor
                  ? TypeValidator<Set<unknown>>
                  : V extends MapConstructor
                    ? TypeValidator<Map<unknown, unknown>>
                    : V extends ObjectConstructor
                      ? TypeValidator<{
                          [key: string | number | symbol]: unknown;
                        }>
                      : V extends DateConstructor
                        ? TypeValidator<Date>
                        : V extends FunctionConstructor
                          ? TypeValidator<Function>
                          : V extends ArrayBufferConstructor
                            ? TypeValidator<ArrayBuffer>
                            : V extends SharedArrayBufferConstructor
                              ? TypeValidator<SharedArrayBuffer>
                              : V extends DataViewConstructor
                                ? TypeValidator<DataView>
                                : V extends Int8ArrayConstructor
                                  ? TypeValidator<Int8Array>
                                  : V extends Uint8ArrayConstructor
                                    ? TypeValidator<Uint8Array>
                                    : V extends Uint8ClampedArrayConstructor
                                      ? TypeValidator<Uint8ClampedArray>
                                      : V extends Int16ArrayConstructor
                                        ? TypeValidator<Int16Array>
                                        : V extends Uint16ArrayConstructor
                                          ? TypeValidator<Uint16Array>
                                          : V extends Int32ArrayConstructor
                                            ? TypeValidator<Int32Array>
                                            : V extends Uint32ArrayConstructor
                                              ? TypeValidator<Uint32Array>
                                              : V extends Float32ArrayConstructor
                                                ? TypeValidator<Float32Array>
                                                : V extends Float64ArrayConstructor
                                                  ? TypeValidator<Float64Array>
                                                  : V extends RegExp
                                                    ? TypeValidator<string>
                                                    : V extends {}
                                                      ? TypeValidator<{
                                                          [key in keyof V]: CoerceToTypeValidator<
                                                            V[key]
                                                          >;
                                                        }>
                                                      : V extends []
                                                        ? TypeValidator<[]>
                                                        : V extends [any]
                                                          ? TypeValidator<
                                                              Array<
                                                                CoerceToTypeValidator<
                                                                  V[0]
                                                                >
                                                              >
                                                            >
                                                          : V extends Array<any>
                                                            ? TypeValidator<
                                                                Array<unknown>
                                                              >
                                                            : V extends {
                                                                  new (
                                                                    ...args: any
                                                                  ): any;
                                                                }
                                                              ? TypeValidator<
                                                                  InstanceType<V>
                                                                >
                                                              : TypeValidator<V>;

declare type CoerceableToTypeValidator =
  | boolean
  | number
  | string
  | bigint
  | undefined
  | null
  | RegExp
  | StringConstructor
  | NumberConstructor
  | BooleanConstructor
  | BigIntConstructor
  | SymbolConstructor
  | RegExpConstructor
  | ArrayConstructor
  | SetConstructor
  | MapConstructor
  | ObjectConstructor
  | DateConstructor
  | FunctionConstructor
  | ArrayBufferConstructor
  | SharedArrayBufferConstructor
  | DataViewConstructor
  | Int8ArrayConstructor
  | Uint8ArrayConstructor
  | Uint8ClampedArrayConstructor
  | Int16ArrayConstructor
  | Uint16ArrayConstructor
  | Int32ArrayConstructor
  | Uint32ArrayConstructor
  | Float32ArrayConstructor
  | Float64ArrayConstructor
  | {}
  | []
  | [any]
  | Array<any>
  | {
      new (...args: any): any;
    };

declare type UnwrapTypeFromCoerceableOrValidator<
  V extends CoerceableToTypeValidator | TypeValidator<any> | unknown,
> =
  V extends TypeValidator<infer T>
    ? T
    : V extends CoerceableToTypeValidator
      ? CoerceToTypeValidator<V> extends TypeValidator<infer T>
        ? T
        : never
      : unknown;

/**
 * Returns whether `value` is of type `type`. Useful for validating that values
 * have the correct type at runtime, in library functions or etc.
 *
 * The `type` parameter can be any of the following:
 *
 * - a TypeValidator function from the `types` namespace
 * - a global constructor like `String`, `Number`, `Boolean`, `Set`,
 *   `Int8Array`, etc
 * - a user-defined class
 * - a primitive value like `true`, `false`, `null`, or `42`
 * - a Regular Expression (to match strings that match the regexp)
 * - an object or array containing any combination of the above
 *
 * Note that yavascript has the following global aliases defined, which are also
 * valid types:
 *
 * ```ts
 * const bigint = BigInt;
 * const boolean = Boolean;
 * const number = Number;
 * const string = String;
 * const symbol = Symbol;
 * ```
 *
 * ## Example
 *
 * ```ts
 * is(42, Number); // true
 * is(42, number); // true
 * is(42, types.number); // true
 *
 * is(42, String); // false
 * is(42, Set); // false
 * is(42, Array); // false
 *
 * is(42, 42); // true
 * is(42, 45); // false
 *
 * is({ kind: "success", data: 99 }, { kind: "success" }); // true
 * ```
 *
 * ```ts
 * // Defined in yavascript/src/api/is
 * declare function is(value: any, type: TypeValidator<any>): boolean;
 * ```
 *
 * See also {@link types} (which contains {@link TypeValidator}s that can be
 * used by `is`) and {@link assert.type} (which throws an error instead of
 * returning a boolean).
 */
declare const is: <T extends TypeValidator<any> | CoerceableToTypeValidator>(
  value: any,
  type: T,
) => value is UnwrapTypeFromCoerceableOrValidator<T>;

/**
 * Alias to {@link is}, for when using the Civet language, because `is` is a
 * reserved keyword in Civet.
 */
declare const _is: typeof is;

declare const assert: {
  /**
   * Throws an error if `value` is not truthy.
   *
   * @param value - The value to test for truthiness
   * @param message - An optional error message to use. If unspecified, "Assertion failed" will be used.
   *
   * **Example**
   * ```ts
   * const files = ls();
   * assert(files.length > 0, "Expected the current directory to have files");
   * ```
   */
  <ValueType>(
    value: ValueType,
    message?: string,
  ): asserts value is ValueType extends null | undefined | false | 0 | ""
    ? never
    : ValueType;

  /**
   * Throws an error if its argument isn't the correct type.
   *
   * @param value - The value to test the type of
   * @param type - The type that `value` should be, as either a `TypeValidator` (from the `types.*` namespace) or a value which can be coerced into a `TypeValidator` via the `types.coerce` function, like `String`, `Boolean`, etc.
   * @param message - An optional error message to use. If unspecified, a generic-but-descriptive message will be used.
   *
   * **Example**
   * ```ts
   * const port: unknown = 8080;
   * assert.type(port, Number, "port must be a number");
   * console.log(port.toFixed(0));
   * ```
   */
  type: <T extends TypeValidator<any> | CoerceableToTypeValidator>(
    value: any,
    type: T,
    optionalMessage?: string,
  ) => asserts value is UnwrapTypeFromCoerceableOrValidator<T>;
};

/**
 * Reads lines from the user one at a time, with readline-style editing keys,
 * history recall and Tab completion.
 *
 * ```ts
 * const prompt = new InteractivePrompt(
 *   (input) => {
 *     console.log("you typed:", input);
 *   },
 *   { prompt: () => "say something> " },
 * );
 * prompt.start();
 * ```
 *
 * The keys it binds, none of which you have to set up yourself:
 *
 * Moving about:
 *
 * - Left and Right, or Ctrl+B and Ctrl+F, move by one character
 * - Ctrl+Left and Ctrl+Right, or Alt+B and Alt+F, move by one word
 * - Home or Ctrl+A goes to the start of the line, End or Ctrl+E to the end
 *
 * Deleting:
 *
 * - Backspace, or Ctrl+H, deletes the character before the cursor
 * - Delete, or Ctrl+D with something typed, deletes the one under it
 * - Ctrl+W or Alt+Backspace cuts the word before the cursor, Alt+D the one
 *   after it
 * - Ctrl+K cuts to the end of the line, Alt+K to the start
 * - Ctrl+Y pastes back whatever was cut last, and consecutive cuts join
 *   together into one piece
 * - Ctrl+X clears the line outright
 *
 * Rearranging what is there:
 *
 * - Ctrl+T swaps the two characters around the cursor, Alt+T the two words
 * - Alt+U puts the next word in upper case, Alt+L in lower case
 *
 * History, completion and finishing:
 *
 * - Up and Down, or Ctrl+P and Ctrl+N, step through previous lines
 * - Page Up and Page Down look through them for one starting with whatever has
 *   been typed so far
 * - Tab completes, and pressing it again lists the candidates when more than
 *   one of them fits
 * - Enter, or Ctrl+J, hands the line to `handleInput`; Ctrl+G abandons it
 * - Ctrl+Q takes the next key literally, so a control character can be typed
 * - Ctrl+D on an empty line stops the prompt, and Ctrl+C twice in a row exits
 *
 * Ctrl+R and Ctrl+S do nothing: there is no incremental search.
 */
declare var InteractivePrompt: InteractivePromptConstructor;

interface InteractivePromptConstructor {
  /**
   * Make a prompt which calls `handleInput` with each line the user enters.
   * Nothing is printed and no input is read until you call `start`.
   *
   * **Example**
   * ```ts
   * const prompt = new InteractivePrompt((input) => {
   *   console.log("you typed:", input);
   * });
   * prompt.start();
   * ```
   */
  new (
    handleInput: (input: string) => void,
    options?: {
      /**
       * The text to print in front of the line the user is editing. Called once
       * for each new line, so it can change as your program does.
       *
       * Defaults to `"> "`.
       *
       * **Example**
       * ```ts
       * const prompt = new InteractivePrompt(console.log, {
       *   prompt: () => `${pwd().basename()}> `,
       * });
       * ```
       */
      prompt?: () => string;

      /**
       * Draws the line the user is editing, receiving its current text. Write
       * it out yourself using `std.puts`, so that you can colour it or mark
       * it up; do not add a trailing newline.
       *
       * Providing this also means the whole line is redrawn on every keystroke,
       * which is what any highlighting needs, since a character typed now can
       * change how earlier ones should look. Leave it out and the line is
       * echoed plainly as it is typed.
       *
       * **Example**
       * ```ts
       * const prompt = new InteractivePrompt(console.log, {
       *   printInput: (input) => std.puts(cyan(input)),
       * });
       * ```
       */
      printInput?: (input: string) => void;

      /**
       * Name of a file to keep this prompt's history in. Every line the user
       * accepts is appended to it, and a prompt started later with the same
       * name begins with those lines already loaded, so the up and down arrows
       * reach them. Leave it out and history lasts only as long as the prompt
       * is running.
       *
       * The file is placed in yavascript's config directory, which is:
       *
       * - on Windows: `yavascript` inside `%APPDATA%`
       * - on macOS: `Library/Application Support/yavascript` inside `$HOME`
       * - anywhere else: `yavascript` inside `$XDG_CONFIG_HOME`, or
       *   `.config/yavascript` inside `$HOME` when `$XDG_CONFIG_HOME` is not
       *   set
       *
       * Should the environment variable a platform relies on be unset, there is
       * nowhere to write the file, and history is kept for the current session
       * only as though no name had been given.
       *
       * **Example**
       * ```ts
       * const prompt = new InteractivePrompt(console.log, {
       *   historyFileName: "my-tool-history.txt",
       * });
       * ```
       */
      historyFileName?: string;

      /**
       * The completions available at `cursorIndex` within `line`. Called every
       * time the user presses Tab.
       *
       * **Example**
       * ```ts
       * const commands = ["help", "status", "quit"];
       * const prompt = new InteractivePrompt(console.log, {
       *   getCompletions: (line, cursorIndex) => ({
       *     candidates: commands.filter((command) => command.startsWith(line)),
       *     prefixLength: cursorIndex,
       *   }),
       * });
       * ```
       */
      getCompletions?: (
        line: string,
        cursorIndex: number,
      ) => InteractivePromptCompletions;
    },
  ): InteractivePrompt;

  prototype: InteractivePrompt;
}

/**
 * A prompt which reads lines from the user, with readline-style editing keys,
 * history recall and Tab completion. See the `InteractivePrompt` global for the
 * full list of keys it binds.
 *
 * **Example**
 * ```ts
 * const prompt: InteractivePrompt = new InteractivePrompt((input) => {
 *   console.log(input.toUpperCase());
 * });
 * prompt.start();
 * ```
 */
interface InteractivePrompt {
  /**
   * The text to print in front of the line the user is editing. Called once for
   * each new line, so it can change as your program does.
   *
   * Defaults to `"> "`.
   *
   * **Example**
   * ```ts
   * const prompt = new InteractivePrompt(console.log);
   * prompt.prompt = () => "$ ";
   * ```
   */
  prompt?: () => string;

  /**
   * Draws the line the user is editing, receiving its current text. Write it
   * out yourself using `std.puts`, so that you can colour it or mark it up; do
   * not add a trailing newline.
   *
   * Providing this also means the whole line is redrawn on every keystroke,
   * which is what any highlighting needs, since a character typed now can
   * change how earlier ones should look. Leave it out and the line is echoed
   * plainly as it is typed.
   *
   * **Example**
   * ```ts
   * const prompt = new InteractivePrompt(console.log);
   * prompt.printInput = (input) => std.puts(bold(input));
   * ```
   */
  printInput?: (input: string) => void;

  /**
   * Name of a file to keep this prompt's history in. Every line the user
   * accepts is appended to it, and a prompt started later with the same name
   * begins with those lines already loaded, so the up and down arrows reach
   * them. Leave it out and history lasts only as long as the prompt is running.
   *
   * The file is placed in yavascript's config directory, which is:
   *
   * - on Windows: `yavascript` inside `%APPDATA%`
   * - on macOS: `Library/Application Support/yavascript` inside `$HOME`
   * - anywhere else: `yavascript` inside `$XDG_CONFIG_HOME`, or
   *   `.config/yavascript` inside `$HOME` when `$XDG_CONFIG_HOME` is not set
   *
   * Should the environment variable a platform relies on be unset, there is
   * nowhere to write the file, and history is kept for the current session only
   * as though no name had been given.
   *
   * **Example**
   * ```ts
   * const prompt = new InteractivePrompt(console.log);
   * prompt.historyFileName = "my-tool-history.txt";
   * ```
   */
  historyFileName?: string;

  /**
   * The completions available at `cursorIndex` within `line`. Called every time
   * the user presses Tab.
   *
   * **Example**
   * ```ts
   * const commands = ["help", "status", "quit"];
   * const prompt = new InteractivePrompt(console.log);
   * prompt.getCompletions = (line, cursorIndex) => ({
   *   candidates: commands.filter((command) => command.startsWith(line)),
   *   prefixLength: cursorIndex,
   * });
   * ```
   */
  getCompletions?: (
    line: string,
    cursorIndex: number,
  ) => InteractivePromptCompletions;

  /**
   * Called with each line the user accepts by pressing Enter. Lines arrive one
   * at a time; nothing is held back waiting for a multi-line construct to be
   * finished off.
   *
   * **Example**
   * ```ts
   * const prompt = new InteractivePrompt(() => {});
   * prompt.handleInput = (input) => {
   *   console.log("you typed:", input);
   * };
   * ```
   */
  handleInput: (input: string) => void;

  /**
   * Print the first prompt and begin reading.
   *
   * This returns straight away instead of blocking; the prompt keeps running
   * off the event loop afterwards. It stops when the user presses Ctrl+D on an
   * empty line, or exits the process when they press Ctrl+C twice in a row.
   *
   * **Example**
   * ```ts
   * const prompt = new InteractivePrompt((input) => {
   *   console.log("you typed:", input);
   * });
   * prompt.start();
   * console.log("this prints before the user has typed anything");
   * ```
   */
  start(): void;
}

/**
 * The candidate completions for a position in a line, as returned by
 * `InteractivePrompt`'s `getCompletions`.
 *
 * **Example**
 * ```ts
 * const completions: InteractivePromptCompletions = {
 *   candidates: ["parse", "stringify"],
 *   prefixLength: 0,
 * };
 * ```
 */
interface InteractivePromptCompletions {
  /**
   * The whole words which could complete what is being typed, rather than just
   * the parts still missing. When several of them match, pressing Tab a second
   * time lists these for the user to pick from, so they need to read as
   * complete words on their own.
   *
   * **Example**
   * ```ts
   * const completions: InteractivePromptCompletions = {
   *   candidates: ["status", "stash", "switch"],
   *   prefixLength: 1,
   * };
   * ```
   */
  candidates: Array<string>;
  /**
   * How many characters at the start of the candidates are already in the line,
   * immediately before the cursor. Those are left alone and the rest of the
   * candidate is typed in.
   *
   * Another way to read it: this is where you consider the word being completed
   * to begin, so what counts as one word is entirely up to you. A completer for
   * property names might treat a dot as a boundary, while one for file paths
   * would keep going through slashes.
   *
   * With `JSON.pars` typed and `parse` offered, a `prefixLength` of 4 leaves
   * `pars` as it is and types in the `e`.
   *
   * A candidate with a `prefixLength` of 0 shares nothing with the line and is
   * typed in whole, which is how you offer something that follows a finished
   * word instead of completing one: once `JSON.parse` is fully typed, offering
   * `(` gives the user `JSON.parse(`.
   *
   * **Example**
   * ```ts
   * const completions: InteractivePromptCompletions = {
   *   candidates: ["parse"],
   *   prefixLength: "pars".length,
   * };
   * ```
   */
  prefixLength: number;
}

/**
 * Launch the Yavascript REPL (read-eval-print-loop).
 *
 * @param context Variables to make available as globals within the repl.
 * @param lang The language to use in the repl. Defaults to "javascript".
 *
 * **Example**
 * ```ts
 * startRepl({ answer: 42 }, "typescript");
 * ```
 */
declare const startRepl: {
  (
    context?: { [key: string]: any },
    lang?:
      | "js"
      | "javascript"
      | "ts"
      | "typescript"
      | "jsx"
      | "tsx"
      | "coffee"
      | "coffeescript"
      | "civet",
  ): void;

  /**
   * A special value; when expressions result in this value, the repl will
   * print nothing instead of printing this value.
   *
   * **Example**
   * ```ts
   * startRepl({
   *   quietly: (fn: () => void) => {
   *     fn();
   *     return startRepl.NOTHING;
   *   },
   * });
   * ```
   */
  NOTHING: symbol;
};

/**
 * An object that points to a git repository on disk and provides utility
 * methods for getting information from that repo.
 *
 * To use it, construct a GitRepo object, passing in the path to the repo:
 *
 * ```ts
 * // The path here is just an example
 * const repo = new GitRepo("/home/suchipi/Code/yavascript");
 * ```
 *
 * Then, you can use methods/properties on the `repo` object:
 *
 * ```ts
 * console.log(repo.branchName() || repo.commitSHA());
 * ```
 */
declare class GitRepo {
  /**
   * Given a path to a file or folder on disk, searches upwards through the
   * directory ancestry to find a `.git` folder, then returns the Path that
   * contains that `.git` folder. If no `.git` folder is found, an error will be
   * thrown.
   *
   * For example, if you have a git repo at `/home/suchipi/Code/my-project`,
   * such that `/home/suchipi/Code/my-project/.git` exists, calling
   * `GitRepo.findRoot("/home/suchipi/Code/my-project/src/index.js")` will
   * return a `Path` object pointing to `/home/suchipi/Code/my-project`.
   *
   * This function can be useful in order to set the current working directory
   * of a script relative to the root of the git repo the script appears in. By
   * doing so, the script can be invoked from any directory.
   *
   * For instance, consider this theoretical filesystem layout:
   *
   * ```
   * my-project
   * - src
   *   - my-script.js
   * - README.md
   * ```
   *
   * If `my-script.js` contained the following content:
   *
   * ```ts
   * #!/usr/bin/env yavascript
   *
   * cat("README.md");
   * ```
   *
   * Then running `src/my-script.js` would print the contents of the README as
   * expected.
   *
   * However, suppose someone ran the script from a different folder:
   *
   * ```sh
   * $ cd src
   * $ ./my-script.js
   * ```
   *
   * Now an error occurs!
   *
   * To make the script resilient against this, you can use `cd` at the top of
   * the script:
   *
   * ```ts
   * #!/usr/bin/env yavascript
   *
   * // __dirname is a special variable that refers to the folder the current script is in.
   * cd(__dirname);
   * cd("..");
   *
   * cat("README.md");
   * ```
   *
   * However, if the location of `my-script.js` later changes, you will have to
   * remember to update the script. For instance, if `src/my-script.js` got
   * moved to `src/tools/my-script.js`, you would need to update the script like
   * so:
   *
   * ```ts
   * #!/usr/bin/env yavascript
   *
   * cd(__dirname);
   * cd("../.."); // Changed this line
   *
   * cat("README.md");
   * ```
   *
   * Since `README.md` will always be in the repository root, using
   * `GitRepo.findRoot` would make the `cd` resilient against file moves:
   *
   * ```ts
   * #!/usr/bin/env yavascript
   *
   * cd(GitRepo.findRoot(__dirname));
   *
   * cat("README.md");
   * ```
   *
   * Depending on how you anticipate your codebase changing over time, and how
   * you expect others to use your scripts, it might make sense to use
   * `cd(__dirname)`, `cd(GitRepo.findRoot(__dirname))`, or no `cd` at all. Pick what
   * makes the most sense for your situation.
   *
   */
  static findRoot(fromPath: string | Path): Path;

  /**
   * Creates a new `GitRepo` object for the given repo on disk.
   *
   * **Example**
   * ```ts
   * const repo = new GitRepo(GitRepo.findRoot(pwd()));
   * console.log(repo.branchName());
   * ```
   */
  constructor(repoDir: string | Path);

  /**
   * The root folder of the git repo that this `GitRepo` object represents (the
   * folder that contains the '.git' folder).
   *
   * **Example**
   * ```ts
   * const repo = new GitRepo(GitRepo.findRoot(pwd()));
   * cd(repo.repoDir);
   * ```
   */
  repoDir: Path;

  /**
   * Returns the full SHA-1 hash string associated with the repo's current
   * commit.
   *
   * For example:
   *
   * ```ts
   * const repo = new GitRepo(".");
   * const sha = repo.commitSHA();
   * console.log(sha);
   * // "2a0a15f9872406faebcac694562efeae3447a4ba"
   * ```
   *
   * To obtain this information, the command `git rev-parse HEAD` gets run
   * within the repo's directory.
   *
   * > If the repo has unstaged or uncommitted changes, that state will NOT be
   * > reflected in the SHA-1 hash. As such, it may be desirable to use this
   * > method in conjunction with `GitRepo.prototype.isWorkingTreeDirty`.
   */
  commitSHA(): string;

  /**
   * If the commit SHA the git repo is currently pointed at is the tip of a
   * named branch, returns the branch name. Otherwise, returns `null`.
   *
   * This is done by running `git rev-parse --abbrev-ref HEAD` within the repo
   * directory.
   *
   * Example:
   *
   * ```ts
   * const repo = new GitRepo(".");
   * const branch = repo.branchName();
   * console.log(branch);
   * // "main"
   * ```
   *
   * > The most common situation where there is no current branch is when the
   * > repository is in "detached HEAD" state.
   */
  branchName(): string | null;

  /**
   * Returns a boolean indicating whether there are uncommitted changes in the
   * git repo. `true` means there are changes, `false` means there are no
   * changes (ie. the repo is clean). Staged changes, unstaged changes, and
   * untracked files that aren't ignored all count as changes.
   *
   * **Example**
   * ```ts
   * const repo = new GitRepo(GitRepo.findRoot(pwd()));
   * if (repo.isWorkingTreeDirty()) {
   *   console.log("You have uncommitted changes");
   * }
   * ```
   */
  isWorkingTreeDirty(): boolean;

  /**
   * Returns a boolean indicating whether the provided path is ignored by one or
   * more `.gitignore` files in the repository.
   *
   * Example:
   *
   * ```ts
   * const repo = new GitRepo(".");
   * const ignoreStatus = repo.isIgnored("README.md");
   * console.log(ignoreStatus);
   * // false
   * ```
   *
   * To obtain this information, the command `git check-ignore <the-path>` gets
   * run within the repo's directory.
   *
   * An error will be thrown if the provided path is not within the repository's
   * directory tree. For instance, calling `gitRepo.isIgnored("/tmp")` on a
   * `gitRepo` pointed at `/home/suchipi/my-project` would throw an error,
   * because `/tmp` is not a child of `/home/suchipi/my-project`.
   *
   * > NOTE: When passing relative paths to `isIgnored`, they will be resolved
   * > relative to the repo root, NOT relative to `pwd()`. It's best practice to
   * > always pass around absolute paths in your program instead of relative
   * > ones so that this type of ambiguity is avoided.
   */
  isIgnored(path: string | Path): boolean;
}

/**
 * The logger used internally by yavascript API functions such as {@link which},
 * {@link exec}, {@link copy}, {@link glob}, and more.
 *
 * You can modify the properties on this object in order to configure the
 * amount and style of log output from yavascript API functions.
 *
 * This object behaves similarly to the shell builtin `set -x`.
 *
 * **Example**
 * ```ts
 * logger.trace = console.error;
 * logger.info = () => {};
 * exec("echo hi");
 * ```
 */
declare const logger: {
  /**
   * This property is used as the default value for `trace` in yavascript API
   * functions which receive `logging.trace` as an option, like {@link which},
   * {@link exec}, {@link copy} and {@link glob}.
   *
   * The default value of `logger.trace` is a no-op function.
   *
   * **Example**
   * ```ts
   * logger.trace = (...args) => console.error("[trace]", ...args);
   * which("git");
   * ```
   */
  trace: (...args: Array<any>) => void;

  /**
   * This property is used as the default value for `info` in yavascript API
   * functions which receive `logging.info` as an option, like {@link exec},
   * {@link copy}, and {@link glob}.
   *
   * The default value of `logger.info` writes dimmed text to stderr.
   *
   * **Example**
   * ```ts
   * logger.info = () => {};
   * exec("echo hi");
   * ```
   */
  info: (...args: Array<any>) => void;

  /**
   * This property is used as the default value for `warn` in yavascript API
   * functions which receive `logging.warn` as an option, like {@link readEnvBool}.
   *
   * The default value of `logger.warn` writes yellow text to stderr.
   *
   * **Example**
   * ```ts
   * logger.warn = (...args) => console.error("warning:", ...args);
   * readEnvBool("VERBOSE", false);
   * ```
   */
  warn: (...args: Array<any>) => void;
};

/**
 * The properties of the `JSX` global can be modified to change how JSX syntax
 * gets compiled by yavascript. Those properties are:
 *
 * - `pragma` (string): The JavaScript expression that should be called to
 *   create JSX elements. Defaults to "JSX.createElement".
 * - `pragmaFrag` (string): The JavaScript expression that should be used when
 *   creating JSX fragments. Defaults to "JSX.Fragment".
 * - `createElement` (function): The function used to create JSX elements,
 *   unless `JSX.pragma` has been changed.
 * - `Element` (symbol): used by the default `JSX.createElement` function to
 *   identify JSX elements.
 * - `Fragment` (symbol): used by the default `JSX.createElement` function to
 *   identify JSX fragments. Referenced by the default value for
 *   `JSX.pragmaFrag`.
 *
 * Modifying these properties will change how JSX syntax gets compiled.
 *
 * For instance, to use React for JSX, you could either replace
 * `JSX.createElement` and `JSX.Fragment` with React's versions:
 *
 * ```ts
 * import * as React from "npm:react";
 *
 * JSX.createElement = React.createElement;
 * JSX.Fragment = React.Fragment;
 * ```
 *
 * Or, you could change `JSX.pragma` and `JSX.pragmaFrag` to reference React
 * directly:
 *
 * ```ts
 * JSX.pragma = "React.createElement";
 * JSX.pragmaFrag = "React.Fragment";
 * ```
 *
 * Note however, that changes to `pragma` and `pragmaFrag` will only affect JSX
 * appearing in files which are loaded _after_ the change, but changing
 * `createElement` and `Fragment` will affect all JSX syntax appearing after the
 * change, even within the same file.
 *
 * Whichever approach you take, you should also update `types.JSX.Element` and
 * `types.JSX.Fragment` such that the expression `types.JSX.Element(<a />) &&
 * types.JSX.Fragment(<></>)` is always `true`. To do that for React, you would
 * do:
 *
 * ```ts
 * types.JSX.Element = React.isValidElement;
 * types.JSX.Fragment = (value) => {
 *   return React.isValidElement(value) && value.type === React.Fragment;
 * };
 * ```
 */
declare namespace JSX {
  /**
   *
   * A string containing the expression that should be called to create JSX
   * elements. yavascript's internals use this string to transpile JSX syntax.
   *
   * The default value is "JSX.createElement".
   *
   * If changed, any JSX code loaded afterwards will use a different expression.
   *
   * Note that if you change this, you need to verify that the following
   * expression always evaluates to `true` (by changing `types.JSX.Element` and
   * `types.JSX.Fragment`):
   *
   * ```jsx
   * types.JSX.Element(<a />) && types.JSX.Fragment(<></>);
   * ```
   *
   * Failure to uphold this guarantee indicates a bug.
   *
   * For more info, including info on how to change how JSX is compiled, see
   * {@link JSX}.
   *
   * **Example**
   * ```ts
   * JSX.pragma = "React.createElement";
   * ```
   */
  export let pragma: string;

  /**
   * A string containing the expression that should be used as the first
   * parameter when creating JSX fragment elements. yavascript's internals use
   * this string to transpile JSX syntax.
   *
   * Defaults to "JSX.Fragment".
   *
   * If changed, any JSX code loaded afterwards will use a different expression.
   *
   * Note that if you change this, you need to verify that the following
   * expression always evaluates to `true` (by changing `types.JSX.Element` and
   * `types.JSX.Fragment`):
   *
   * ```jsx
   * types.JSX.Element(<a />) && types.JSX.Fragment(<></>);
   * ```
   *
   * Failure to uphold this guarantee indicates a bug.
   *
   * For more info, including info on how to change how JSX is compiled, see
   * {@link JSX}.
   *
   * **Example**
   * ```ts
   * JSX.pragmaFrag = "React.Fragment";
   * ```
   */
  export let pragmaFrag: string;

  /**
   * `JSX.Element` is a Symbol. The default implementation of
   * `JSX.createElement` creates objects whose `$$typeof` property is set to
   * `JSX.Element`, and type validator functions under the `types.JSX.*`
   * namespace look for this property in order to determine whether an object is
   * a JSX element, as created via `JSX.createElement` or JSX syntax.
   *
   * ```jsx
   * // This gets compiled internally by yavascript into:
   * // const a = JSX.createElement('a', null);
   * const a = <a />;
   *
   * console.log(a);
   * // {
   * //   $$typeof: Symbol(JSX.Element)
   * //   type: "a"
   * //   props: null
   * //   key: null
   * // }
   *
   * console.log(a.$$typeof === JSX.Element);
   * // true
   * ```
   *
   * There is also a TypeScript type called `JSX.Element` which is a type for
   * the JSX element objects as created by `JSX.createElement` or JSX syntax.
   *
   * If you modify properties on the JSX global such that the default
   * implementation of `JSX.createElement` is no longer used (eg. by replacing
   * it with `React.createElement`), this value may no longer be relevant.
   * However, the default JSX element object shape is designed to match
   * React/Preact/etc.
   *
   * For more info, including info on how to change how JSX is compiled, see
   * {@link JSX}.
   *
   */
  export const Element: unique symbol;

  /**
   * The TypeScript type for JSX Element objects created by the default
   * implementation of `JSX.createElement`.
   *
   * **Example**
   * ```tsx
   * const link: JSX.Element<{ href: string }, "a"> = <a href="https://example.com" />;
   * console.log(link.type, link.props.href);
   * ```
   */
  export interface Element<
    Props = { [key: string | symbol | number]: any },
    Type = any,
  > {
    $$typeof: typeof Element;
    type: Type;
    props: Props;
    key: string | number | null;
  }

  /**
   *
   * `JSX.Fragment` is a Symbol which is used to indicate whether a JSX element
   * is a JSX fragment.
   *
   * ```jsx
   * // This gets compiled internally by yavascript into:
   * // const a = JSX.createElement(JSX.Fragment, null);
   * const frag = <></>;
   *
   * console.log(frag);
   * // {
   * //   $$typeof: Symbol(JSX.Element)
   * //   type: Symbol(JSX.Fragment)
   * //   props: null
   * //   key: null
   * // }
   *
   * console.log(a.type === JSX.Fragment);
   * // true
   * ```
   *
   * There is also a TypeScript type called `JSX.Fragment` which is a type for
   * the JSX fragment element objects as created by `JSX.createElement` or JSX
   * syntax.
   *
   * If you modify properties on the JSX global such that `JSX.Fragment` is no
   * longer used (eg. by replacing it with `React.Fragment`), this value may no
   * longer be relevant.
   *
   * For more info, including info on how to change how JSX is compiled, see
   * {@link JSX}.
   */
  export const Fragment: unique symbol;

  /**
   * The TypeScript type for JSX Element objects whose type is `JSX.Fragment`,
   * which is what yavascript creates internally when JSX fragment syntax
   * (`<></>`) is used.
   *
   * If you modify properties on the JSX global such that `JSX.Fragment` is no
   * longer used (eg. by replacing it with `React.Fragment`), this type may no
   * longer be relevant.
   *
   * **Example**
   * ```tsx
   * const fragment: JSX.Fragment = <>hi</>;
   * console.log(fragment.type === JSX.Fragment);
   * ```
   */
  export type Fragment = Element<{}, typeof Fragment>;

  /**
   * The JSX element builder function, which gets invoked internally by
   * yavascript whenever JSX syntax is used (unless `JSX.pragma` gets changed by
   * the user).
   *
   * Note that if you change this, you need to verify that the following
   * expression always evaluates to `true` (by changing `types.JSX.Element` and
   * `types.JSX.Fragment`):
   *
   * ```jsx
   * types.JSX.Element(<a />) && types.JSX.Fragment(<></>);
   * ```
   *
   * Failure to uphold this guarantee indicates a bug.
   *
   * For more info, including info on how to change how JSX is compiled, see
   * {@link JSX}.
   *
   * **Example**
   * ```tsx
   * const link = JSX.createElement(
   *   "a",
   *   { href: "https://example.com" },
   *   "click here",
   * );
   * console.log(link.props.href, link.props.children);
   *
   * // Same as:
   *
   * const link = <a href="https://example.com">click here</a>;
   * console.log(link.props.href, link.props.children);
   * ```
   */
  export let createElement: {
    <Type extends string | typeof Fragment | ((...args: any) => any)>(
      type: Type,
    ): Element<{}, Type>;
    <
      Type extends string | typeof Fragment | ((...args: any) => any),
      Props extends { [key: string | number | symbol]: any },
    >(
      type: Type,
      props: Props,
    ): Element<Props, Type>;

    <
      Type extends string | typeof Fragment | ((...args: any) => any),
      Props extends { [key: string | number | symbol]: any },
      Children extends Array<any>,
    >(
      type: Type,
      props: Props,
      ...children: Children
    ): Element<Props & { children: Children }, Type>;

    <
      Type extends string | typeof Fragment | ((...args: any) => any),
      Children extends Array<any>,
    >(
      type: Type,
      ...children: Children
    ): Element<{ children: Children }, Type>;
  };
}

/**
 * The `YAML` namespace contains functions which can serialize and deserialize
 * YAML documents, following the same pattern as JavaScript's `JSON` builtin.
 *
 * **Example**
 * ```ts
 * const config = YAML.parse(readFile("config.yaml"));
 * config.replicas = 3;
 * writeFile("config.yaml", YAML.stringify(config));
 * ```
 */
declare const YAML: {
  /**
   * Converts a YAML document string into a JavaScript value. It works the same
   * way that `JSON.parse` does, but for YAML.
   *
   * **Example**
   * ```ts
   * const data = YAML.parse("name: my-project\ntags:\n  - one\n  - two\n");
   * console.log(data.name, data.tags);
   * ```
   */
  parse(
    input: string,
    reviver?: (this: any, key: string, value: any) => any,
  ): any;

  /**
   * Converts a JavaScript value into a YAML document string. It works the same
   * way that `JSON.stringify` does, but for YAML.
   *
   * **Example**
   * ```ts
   * const data = { name: "my-project", tags: ["one", "two"] };
   * const yaml = YAML.stringify(data, null, 2);
   * console.log(yaml);
   * ```
   */
  stringify(
    input: any,
    replacer?:
      | ((this: any, key: string, value: any) => any)
      | (number | string)[]
      | null,
    indent?: number,
  ): string;
};

/**
 * Serializes or deserializes CSV data.
 *
 * The `CSV` object contains a `parse` function and a `stringify` function which
 * can be used to parse strings of CSV (comma-separated values) data into
 * arrays-of-arrays-of-strings and serialize arrays-of-arrays-of-strings into
 * strings of CSV data.
 *
 * Its interface is similar to `JSON.parse` and `JSON.stringify`, but CSV does
 * not support the spacing/replacer/reviver options that `JSON.parse` and
 * `JSON.stringify` have.
 *
 * **Example**
 * ```ts
 * const rows = CSV.parse("name,age\nAlice,30\n");
 * rows.push(["Bob", "25"]);
 * console.log(CSV.stringify(rows));
 * ```
 */
declare const CSV: {
  /**
   * Parse a CSV string into an Array of Arrays of strings.
   *
   * The outer array holds the rows, and the inner arrays hold the items in
   * each row.
   *
   * **Example**
   * ```ts
   * const rows = CSV.parse(readFile("data.csv"));
   * for (const [name, age] of rows) {
   *   console.log(name, age);
   * }
   * ```
   */
  parse(input: string): Array<Array<string>>;

  /**
   * Convert an Array of Arrays of strings into a CSV string.
   *
   * The outer array holds the rows, and the inner arrays hold the items in
   * each row.
   *
   * **Example**
   * ```ts
   * const csv = CSV.stringify([
   *   ["name", "age"],
   *   ["Alice", "30"],
   * ]);
   * writeFile("people.csv", csv);
   * ```
   */
  stringify(input: Array<Array<string>>): string;
};

/**
 * An object with a `parse` function and a `stringify` function which can be
 * used to parse TOML document strings into objects and serialize objects into
 * TOML document strings.
 *
 * Its interface is similar to `JSON.parse` and `JSON.stringify`, but
 * `TOML.parse` and `TOML.stringify` do not support the spacing/replacer/reviver
 * options that `JSON.parse` and `JSON.stringify` do.
 *
 * **Example**
 * ```ts
 * const config = TOML.parse(readFile("config.toml"));
 * config.version = "1.0.0";
 * writeFile("config.toml", TOML.stringify(config));
 * ```
 */
declare var TOML: {
  /**
   * Parse a TOML document string (`data`) into an object.
   *
   * **Example**
   * ```ts
   * const toml = 'name = "my-project"\n[build]\ntarget = "dist"\n';
   * const config = TOML.parse(toml);
   * console.log(config.name, config.build.target);
   * ```
   */
  parse(data: string): { [key: string]: any };
  /**
   * Convert an object into a TOML document.
   *
   * **Example**
   * ```ts
   * const toml = TOML.stringify({
   *   name: "my-project",
   *   build: { target: "dist" },
   * });
   * console.log(toml);
   * // name = "my-project"
   * //
   * // [build]
   * // target = "dist"
   * //
   * ```
   */
  stringify(data: { [key: string]: any }): string;
};

interface RegExpConstructor {
  /**
   * The function `RegExp.escape` accepts an input string and escapes those
   * characters in it which would otherwise have a special meaning when
   * appearing in a regular expression.
   *
   * Throws a TypeError if `str` isn't a string.
   */
  escape(str: string): string;
}

interface StringConstructor {
  /**
   * The function `String.dedent` can be used to remove leading indentation from
   * a string. It is commonly used as a tagged template function, but you can
   * also call it and pass in a string.
   *
   * Note that the first line of the string must be empty.
   *
   * `String.dedent` is the default export from the npm package `string-dedent`.
   * See its readme on npm for more info:
   * https://www.npmjs.com/package/string-dedent
   *
   * **Example**
   * ```ts
   * const usage = String.dedent`
   *   Usage: my-script [options]
   *
   *     --help  Show this message
   * `;
   * console.log(usage);
   * ```
   */
  dedent: {
    /**
     * Removes leading minimum indentation from the string `input`.
     * The first line of `input` MUST be empty.
     *
     * For more info, see: https://www.npmjs.com/package/string-dedent#usage
     *
     * **Example**
     * ```ts
     * const text = String.dedent("\n    first line\n      second line\n");
     * console.log(text);
     * ```
     */
    (input: string): string;

    /**
     * Removes leading minimum indentation from the tagged template literal.
     * The first line of the template literal MUST be empty.
     *
     * For more info, see: https://www.npmjs.com/package/string-dedent#usage
     *
     * **Example**
     * ```ts
     * const name = "world";
     * const message = String.dedent`
     *   Hello, ${name}!
     *     This line stays indented by two spaces.
     * `;
     * console.log(message);
     * ```
     */
    (
      strings: readonly string[] | ArrayLike<string>,
      ...substitutions: unknown[]
    ): string;

    /**
     * Wrap another template tag function such that tagged literals
     * become dedented before being passed to the wrapped function.
     *
     * For more info, see: https://www.npmjs.com/package/string-dedent#usage
     *
     * **Example**
     * ```ts
     * const shout = (strings: ArrayLike<string>, ...values: any[]) =>
     *   String.raw({ raw: strings }, ...values).toUpperCase();
     * const dedentedShout = String.dedent(shout);
     * console.log(dedentedShout`
     *   hello
     *     world
     * `);
     * ```
     */
    <
      Func extends (
        strings: readonly string[] | ArrayLike<string>,
        ...substitutions: any[]
      ) => string,
    >(
      input: Func,
    ): Func;
  };
}

interface PromiseConstructor {
  /**
   * Like Promise.all, but instead of running everything at once, it'll only run
   * a few Promises at a time (you can choose how many to run at once). It's
   * inspired by [Bluebird's Promise.map
   * function](https://bluebirdjs.com/docs/api/promise.map.html).
   *
   * To use it, you pass in an iterable (array, set, generator function, etc) of
   * inputs and a mapper function that transforms each input into a Promise. You
   * can also optionally specify the maximum number of Promises to wait on at a
   * time by passing an object with a concurrency property, which is a number.
   * The concurrency defaults to 8.
   *
   * When using an iterable, if the iterable yields a Promise (ie.
   * iterable.next() returns { done: false, value: Promise }), then the yielded
   * Promise will be awaited before being passed into your mapper function.
   * Additionally, async iterables are supported; if iterable.next() returns a
   * Promise, it will be awaited.
   *
   * **Example**
   * ```ts
   * const files = glob("src/*.ts");
   *
   * const lineCounts = await Promise.map(
   *   files,
   *   async (file) => {
   *     // readFile blocks the thread, so we use runInWorker to run
   *     // it in another thread
   *     const lengthFromWorker = await runInWorker(file.toString(), (file) => {
   *       return readFile(file).split("\n").length;
   *     });
   *     return lengthFromWorker;
   *   },
   *   { concurrency: 4 },
   * );
   *
   * console.log(lineCounts);
   * ```
   */
  map<T, U>(
    inputs: Iterable<T | Promise<T>> | AsyncIterable<T | Promise<T>>,
    mapper: (input: T, index: number, length: number) => Promise<U>,
    {
      /**
       * How many jobs are allowed to run at once.
       *
       * **Example**
       * ```ts
       * const delays = [300, 200, 100];
       * await Promise.map(delays, (ms) => sleep.async(ms), { concurrency: 2 });
       * ```
       */
      concurrency,
    }?: {
      /**
       * How many jobs are allowed to run at once.
       *
       * **Example**
       * ```ts
       * const delays = [300, 200, 100];
       * await Promise.map(delays, (ms) => sleep.async(ms), { concurrency: 2 });
       * ```
       */
      concurrency?: number;
    },
  ): Promise<Array<U>>;
}

/**
 * Opens the resource at the given path or URL using the operating system's
 * default application or handler.
 *
 * Examples:
 *
 * ```ts
 * openUrl("/home/me/stuff/code.txt"); // opens code.txt in your default text editor
 * openUrl("code.txt"); // same as above, using relative path
 * openUrl("file:///home/me/stuff/code.txt"); // same as above, using file:// url
 *
 * openUrl("IMG_001.jpg"); // opens IMG_001.jpg in your default image viewer
 *
 * openUrl("https://example.com/") // opens example.com in your default web browser
 * ```
 */
declare function openUrl(urlOrFilePath: string | Path): void;

// prettier-ignore
/**
 * Any integer in the range [0, 255].
 *
 * **Example**
 * ```ts
 * const red: byte = 255;
 * const green: byte = 128;
 * console.log(red, green);
 * ```
 */
declare type byte =
|   0 |   1 |   2 |   3 |   4 |   5 |   6 |   7 |   8 |   9 |  10 |  11 |  12 |  13 |  14 |  15 
|  16 |  17 |  18 |  19 |  20 |  21 |  22 |  23 |  24 |  25 |  26 |  27 |  28 |  29 |  30 |  31 
|  32 |  33 |  34 |  35 |  36 |  37 |  38 |  39 |  40 |  41 |  42 |  43 |  44 |  45 |  46 |  47 
|  48 |  49 |  50 |  51 |  52 |  53 |  54 |  55 |  56 |  57 |  58 |  59 |  60 |  61 |  62 |  63 
|  64 |  65 |  66 |  67 |  68 |  69 |  70 |  71 |  72 |  73 |  74 |  75 |  76 |  77 |  78 |  79 
|  80 |  81 |  82 |  83 |  84 |  85 |  86 |  87 |  88 |  89 |  90 |  91 |  92 |  93 |  94 |  95 
|  96 |  97 |  98 |  99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 
| 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 
| 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 
| 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 
| 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 
| 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 
| 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 
| 208 | 209 | 210 | 211 | 212 | 213 | 214 | 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | 223 
| 224 | 225 | 226 | 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | 239 
| 240 | 241 | 242 | 243 | 244 | 245 | 246 | 247 | 248 | 249 | 250 | 251 | 252 | 253 | 254 | 255;

// Convenience aliases to provide parity with TypeScript types.
declare var number: NumberConstructor;
declare var string: StringConstructor;
declare var boolean: BooleanConstructor;
declare var bigint: BigIntConstructor;
declare var symbol: SymbolConstructor;

declare type TypedArray =
  | Int8Array
  | Uint8Array
  | Uint8ClampedArray
  | Int16Array
  | Uint16Array
  | Int32Array
  | Uint32Array
  | Float32Array
  | Float64Array;
declare type TypedArrayConstructor =
  | Int8ArrayConstructor
  | Uint8ArrayConstructor
  | Uint8ClampedArrayConstructor
  | Int16ArrayConstructor
  | Uint16ArrayConstructor
  | Int32ArrayConstructor
  | Uint32ArrayConstructor
  | Float32ArrayConstructor
  | Float64ArrayConstructor;

interface ErrorOptions {
  [key: string]: any;
}

/**
 * For compatibility with Node.js scripts, the global object is accessible via
 * the global variable named "global".
 *
 * **Example**
 * ```ts
 * console.log(global === globalThis);
 * ```
 */
declare var global: typeof globalThis;

/**
 * A `process` global is provided for rudimentary compatibility with Node.js
 * scripts. It contains a subset of the properties found on the Node.js
 * `process` global, which each forward to their corresponding yavascript API.
 *
 * For instance, `process.env` is a getter that returns {@link env}, and
 * `process.argv` is a getter that returns {@link scriptArgs}.
 *
 * If you are writing yavascript-specific code, you should use yavascript's APIs
 * instead of `process`.
 *
 * **Example**
 * ```ts
 * console.log(process.version, process.arch);
 * console.log(process.argv);
 * ```
 */
declare var process: {
  version: string;
  versions: {
    node: string;
    yavascript: string;
    unicode: string;
  };
  arch: string;
  /**
   * Same as the global {@link env}.
   *
   * **Example**
   * ```ts
   * console.log(process.env.HOME);
   * ```
   */
  readonly env: { [key: string]: string | undefined };
  /**
   * Same as the global {@link scriptArgs}.
   *
   * **Example**
   * ```ts
   * const args = process.argv.slice(2);
   * console.log(args);
   * ```
   */
  readonly argv: Array<string>;
  /**
   * Same as `scriptArgs[0]`.
   *
   * **Example**
   * ```ts
   * console.log(process.argv0);
   * ```
   */
  readonly argv0: string;
  /**
   * Shortcut for `os.realpath(os.execPath())`, using the QuickJS {@link os}
   * module.
   *
   * **Example**
   * ```ts
   * exec([process.execPath, "--version"]);
   * ```
   */
  readonly execPath: string;
  /**
   * Uses `std.getExitCode()` and `std.setExitCode()` from the QuickJS
   * {@link std} module.
   *
   * **Example**
   * ```ts
   * process.exitCode = 1;
   * ```
   */
  exitCode: number;
  /**
   * Uses `std.exit()` from the QuickJS {@link std} module.
   *
   * **Example**
   * ```ts
   * if (process.argv.length < 3) {
   *   console.error("Please specify an input file");
   *   process.exit(1);
   * }
   * ```
   */
  exit(code?: number | null | undefined): void;
};

/**
 * Workers can be used for multi-threaded, concurrent work.
 *
 * YavaScript's global `Worker` class is a subclass of the QuickJS's
 * {@link os.Worker} which loads all of the YavaScript API globals into the
 * Worker's global context.
 *
 * It behaves similar to [Web
 * Workers](https://developer.mozilla.org/en-US/docs/Web/API/Worker).
 *
 * **Example**
 * ```ts
 * const worker = new Worker("./my-worker.js");
 * worker.onmessage = (event) => {
 *   console.log("worker says:", event.data);
 *   worker.terminate();
 * };
 * worker.postMessage({ task: "start" });
 * ```
 */
declare class Worker {
  /**
   * Create a Worker which runs the module at `moduleFilename`.
   *
   * If `options.overrideCode` is present, the Worker instead runs a synthetic
   * module with filename `moduleFilename` and source code
   * `options.overrideCode` (JS source code string). In this case,
   * `moduleFilename` is not read from disk and is only used as the module's
   * assigned filename for import.meta, module resolution, etc.
   *
   * If `options.initialData` is present, it'll be available within the worker
   * as the static `initialData` property on the Worker constructor.
   *
   * **Example**
   * ```ts
   * const worker = new Worker("inline-worker.js", {
   *   overrideCode: "Worker.parent.postMessage(Worker.initialData.name)",
   *   initialData: { name: "bob" },
   * });
   * worker.onmessage = (event) => {
   *   console.log(event.data);
   *   worker.terminate();
   * };
   * ```
   */
  constructor(
    moduleFilename: string,
    options?: {
      overrideCode?: string;
      initialData?: StructuredClonable;
    },
  );

  /**
   * If accessed within a Worker, and the Worker was constructed with
   * non-undefined `initialData`, then this will be a structured clone of that
   * initial data.
   *
   * Outside of a worker, this is always `undefined`.
   *
   * **Example**
   * ```ts
   * const data = Worker.initialData;
   * if (data !== undefined) {
   *   console.log("Running inside a worker with:", data);
   * }
   * ```
   */
  static initialData: StructuredClonable;

  /**
   * Worker-side communication channel back to the parent context that invoked
   * it (ie. the main thread).
   *
   * **Example**
   * ```ts
   * Worker.parent.onmessage = (event) => {
   *   Worker.parent.postMessage({ received: event.data });
   * };
   * ```
   */
  static parent: {
    /**
     * Send a message from the worker back to the main thread.
     *
     * **Example**
     * ```ts
     * Worker.parent.postMessage({ status: "done", result: 42 });
     * ```
     */
    postMessage(msg: StructuredClonable): void;

    /**
     * This function is called when a message arrives from the parent. You may
     * override this property with your own function.
     *
     * **Example**
     * ```ts
     * Worker.parent.onmessage = (event) => {
     *   console.log("message from the main thread:", event.data);
     * };
     * ```
     */
    onmessage: null | ((event: { data: StructuredClonable }) => void);
  };

  /**
   * Send a message from the main thread to the worker.
   *
   * **Example**
   * ```ts
   * const worker = new Worker("./my-worker.js");
   * worker.postMessage({ task: "resize", width: 800 });
   * ```
   */
  postMessage(msg: StructuredClonable): void;

  /**
   * This function is called when a message arrives from the Worker. You may
   * override this property with your own function.
   *
   * **Example**
   * ```ts
   * const worker = new Worker("./my-worker.js");
   * worker.onmessage = (event) => {
   *   console.log("message from the worker:", event.data);
   * };
   * ```
   */
  onmessage: null | ((event: { data: StructuredClonable }) => void);

  /**
   * If an unhandled Error is thrown in the Worker or an unhandled Promise is
   * rejected in the worker, this `onerror` function will be run.
   *
   * When `onerror` is unset, errors print to stderr.
   *
   * **Example**
   * ```ts
   * const worker = new Worker("./my-worker.js");
   * worker.onerror = (event) => {
   *   console.error(`${event.filename}:${event.lineno}: ${event.message}`);
   * };
   * ```
   */
  onerror:
    | null
    | ((event: {
        message: string;
        filename: string;
        lineno: number;
        error: Error | null;
      }) => void);

  /**
   * Terminate the worker thread. Equivalent to setting `onmessage` to `null`.
   *
   * **Example**
   * ```ts
   * const worker = new Worker("./my-worker.js");
   * worker.onmessage = () => {
   *   worker.terminate();
   * };
   * ```
   */
  terminate(): void;
}

/**
 * Types which can be sent to/from Workers.
 *
 * **Example**
 * ```ts
 * const message: StructuredClonable = {
 *   name: "resize",
 *   sizes: [640, 1280],
 *   createdAt: new Date(),
 * };
 * ```
 */
declare type StructuredClonable =
  | string
  | number
  | boolean
  | null
  | undefined
  | Boolean
  | String
  | Date
  | RegExp
  | ArrayBuffer
  | Int8Array
  | Uint8Array
  | Uint8ClampedArray
  | Int16Array
  | Uint16Array
  | Int32Array
  | Uint32Array
  | Float32Array
  | Float64Array
  | BigInt64Array
  | BigUint64Array
  | DataView
  | Array<StructuredClonable>
  | SharedArrayBuffer
  | { [key: string | number]: StructuredClonable };

/**
 * Run the following function inside of a {@link Worker} (ie another thread).
 *
 * @param inputs - Values to clone across to the worker and pass into the function.
 * @param workerFunction - Sync or async function to run on the worker side, which receives `inputs` as its first argument.
 * @returns A Promise which resolves to `workerFunction(inputs)` (evaluated in the worker thread).
 *
 * > NOTE: `workerFunction` gets turned into a source code string which gets
 * > evaluated in the other thread. Therefore, it can't access any closure
 * > variables. To pass data into the function, use the `inputs` parameter.
 *
 * Example:
 *
 * ```ts
 * const someName = "bob";
 * // By passing `someName` as a property of `inputs` and destructuring it from
 * // the first parameter to `workerFunction`, we can reference it with the same
 * // name it uses outside of `workerFunction`. It's not a true closure, but it
 * // feels like one.
 * const uppercased = runInWorker({ someName }, ({ someName }) => {
 *   return someName.toUpperCase();
 * });
 * console.log(uppercased); // "BOB"
 * ```
 *
 * If you need to access imports inside the worker, use {@link require}.
 *
 * > NOTE: Because `inputs` and the return value of `workerFunction` must cross
 * > the thread boundary, the data is cloned and re-created on the other side.
 * > Not all types can be cloned. The types which can be cloned are: `string`,
 * > `number`, `boolean`, `null`, `undefined`, Arrays, Objects, `Date`,
 * > `RegExp`, `ArrayBuffer`, Typed arrays, `DataView`, and instances of native
 * > Error constructors (`Error`, `TypeError`, etc).
 * >
 * > SharedArrayBuffer can also be used to shared live data across the worker
 * > and main thread.
 */
declare function runInWorker<
  Inputs extends import("quickjs:os").StructuredClonable,
  Output extends import("quickjs:os").StructuredClonable,
>(
  inputs: Inputs,
  workerFunction: (inputs: Inputs) => Promise<Output>,
): Promise<Output>;

/**
 * A separate global context (or 'realm') within which code can be executed.
 *
 * This is the same as {@link import("quickjs:context")}, but with a
 * `yavascriptGlobals` option added.
 *
 * **Example**
 * ```ts
 * const context = new Context();
 * context.eval("globalThis.x = 5");
 * console.log(context.eval("x * 2"));
 * ```
 */
declare class Context {
  /**
   * Create a new global context (or 'realm') within code can be executed.
   *
   * @param options Options for what globals/modules/etc to make available within the context.
   *
   * The following globals are always present, regardless of options:
   *
   * - Object
   * - Function
   * - Error
   * - EvalError
   * - RangeError
   * - ReferenceError
   * - SyntaxError
   * - TypeError
   * - URIError
   * - InternalError
   * - AggregateError
   * - Array
   * - parseInt
   * - parseFloat
   * - isNaN
   * - isFinite
   * - decodeURI
   * - decodeURIComponent
   * - encodeURI
   * - encodeURIComponent
   * - escape
   * - unescape
   * - Infinity
   * - NaN
   * - undefined
   * - Number
   * - Boolean
   * - String
   * - Math
   * - Reflect
   * - Symbol
   * - eval (but it doesn't work unless the `eval` option is enabled)
   * - globalThis
   *
   * Note that new contexts don't have a `scriptArgs` global. If you need one
   * to be present in the new context, you can add one onto the Context's
   * `globalThis` property.
   *
   * **Example**
   * ```ts
   * const sandbox = new Context({
   *   yavascriptGlobals: false,
   *   moduleGlobals: false,
   *   timers: false,
   * });
   * console.log(sandbox.eval("typeof setTimeout"));
   * ```
   */
  constructor(options?: {
    /**
     * Enables `Date`. Defaults to `true`.
     *
     * **Example**
     * ```ts
     * const context = new Context({ date: false, yavascriptGlobals: false });
     * console.log(context.eval("typeof Date"));
     * ```
     */
    date?: boolean;

    /**
     * Enables `eval`, Function constructor, etc. Defaults to `true`.
     *
     * > NOTE: The {@link Context.eval} method will still work even with this
     * > option set to false. This option only disables eval *within* the
     * > context.
     *
     * **Example**
     * ```ts
     * const context = new Context({ eval: false });
     * console.log(context.eval("1 + 1"));
     * ```
     */
    eval?: boolean;

    /**
     * Enables `String.prototype.normalize`. Defaults to `true`.
     *
     * **Example**
     * ```ts
     * const context = new Context({ stringNormalize: false });
     * console.log(context.eval("typeof String.prototype.normalize"));
     * ```
     */
    stringNormalize?: boolean;

    /**
     * Enables `RegExp`. Defaults to `true`.
     *
     * **Example**
     * ```ts
     * const context = new Context({ regExp: false, yavascriptGlobals: false });
     * console.log(context.eval("typeof RegExp"));
     * ```
     */
    regExp?: boolean;

    /**
     * Enables `JSON`. Defaults to `true`.
     *
     * **Example**
     * ```ts
     * const context = new Context({ json: false });
     * console.log(context.eval("typeof JSON"));
     * ```
     */
    json?: boolean;

    /**
     * Enables `Proxy`. Defaults to `true`.
     *
     * **Example**
     * ```ts
     * const context = new Context({ proxy: false, yavascriptGlobals: false });
     * console.log(context.eval("typeof Proxy"));
     * ```
     */
    proxy?: boolean;

    /**
     * Enables `Map` and `Set`. Defaults to `true`.
     *
     * **Example**
     * ```ts
     * const context = new Context({ mapSet: false, yavascriptGlobals: false });
     * console.log(context.eval("typeof Map"), context.eval("typeof Set"));
     * ```
     */
    mapSet?: boolean;

    /**
     * Enables:
     *
     * - ArrayBuffer
     * - SharedArrayBuffer
     * - Uint8ClampedArray
     * - Int8Array
     * - Uint8Array
     * - Int16Array
     * - Uint16Array
     * - Int32Array
     * - Uint32Array
     * - BigInt64Array
     * - BigUint64Array
     * - Float32Array
     * - Float64Array
     * - DataView
     *
     * Defaults to `true`.
     *
     * **Example**
     * ```ts
     * const context = new Context({ typedArrays: false });
     * console.log(context.eval("typeof Uint8Array"));
     * ```
     */
    typedArrays?: boolean;

    /**
     * Enables:
     *
     * - Promise
     * - async functions
     * - async iterators
     * - async generators
     *
     * Defaults to `true`.
     *
     * **Example**
     * ```ts
     * const context = new Context({
     *   promise: false,
     *   yavascriptGlobals: false,
     * });
     * console.log(context.eval("typeof Promise"));
     * ```
     */
    promise?: boolean;

    /**
     * Enables `inspect`. Defaults to `true`.
     *
     * **Example**
     * ```ts
     * const context = new Context({
     *   inspect: false,
     *   yavascriptGlobals: false,
     * });
     * console.log(context.eval("typeof inspect"));
     * ```
     */
    inspect?: boolean;
    /**
     * Enables the QuickJS `console` object. Defaults to `true`.
     *
     * YavaScript extends the builtin QuickJS `console` by passing its arguments
     * through `inspect`. To gain this functionality, pass option
     * `yavascriptGlobals: true`.
     *
     * **Example**
     * ```ts
     * const context = new Context({
     *   console: false,
     *   yavascriptGlobals: false,
     * });
     * console.log(context.eval("typeof console"));
     * ```
     */
    console?: boolean;
    /**
     * Enables the QuickJS `print` object. Defaults to `true`.
     *
     * YavaScript extends the builtin QuickJS `print` by passing its arguments
     * through `inspect`. To gain this functionality, pass option
     * `yavascriptGlobals: true`.
     *
     * **Example**
     * ```ts
     * const context = new Context({ print: false, yavascriptGlobals: false });
     * console.log(context.eval("typeof print"));
     * ```
     */
    print?: boolean;
    /**
     * Enables `require`. Defaults to `true`.
     *
     * **Example**
     * ```ts
     * const context = new Context({
     *   moduleGlobals: false,
     *   yavascriptGlobals: false,
     * });
     * console.log(context.eval("typeof require"));
     * ```
     */
    moduleGlobals?: boolean;
    /**
     * Enables `setTimeout`, `clearTimeout`, `setInterval`, and
     * `clearInterval`. Defaults to `true`.
     *
     * **Example**
     * ```ts
     * const context = new Context({ timers: false });
     * console.log(context.eval("typeof setTimeout"));
     * ```
     */
    timers?: boolean;

    /**
     * Enables YavaScript's builtin global APIs, like `exec`, `assert`, `TOML`,
     * etc.
     *
     * Defaults to `true`.
     *
     * > NOTE: Be aware that the Context's `Context`, `Worker`, and
     * > `runInWorker` globals get created in the main context. Some obscure
     * > things (like `instanceof Function`) therefore won't work, but
     * > everything that matters in practice will work just fine. All other
     * > globals get created within the child context.
     *
     * **Example**
     * ```ts
     * const context = new Context({ yavascriptGlobals: false });
     * console.log(context.eval("typeof exec"));
     * ```
     */
    yavascriptGlobals?: boolean;

    /**
     * Enable builtin modules.
     *
     * **Example**
     * ```ts
     * const context = new Context({
     *   yavascriptGlobals: false,
     *   modules: { "quickjs:os": false, "quickjs:std": false },
     * });
     * ```
     */
    modules?: {
      /**
       * Enables the "quickjs:bytecode" module. Defaults to `true`.
       *
       * **Example**
       * ```ts
       * const context = new Context({
       *   yavascriptGlobals: false,
       *   modules: { "quickjs:bytecode": false },
       * });
       * ```
       */
      "quickjs:bytecode"?: boolean;
      /**
       * Enables the "quickjs:cmdline" module. Defaults to `true`.
       *
       * **Example**
       * ```ts
       * const context = new Context({
       *   yavascriptGlobals: false,
       *   modules: { "quickjs:cmdline": false },
       * });
       * ```
       */
      "quickjs:cmdline"?: boolean;
      /**
       * Enables the "quickjs:context" module. Defaults to `true`.
       *
       * **Example**
       * ```ts
       * const context = new Context({
       *   modules: { "quickjs:context": false },
       * });
       * ```
       */
      "quickjs:context"?: boolean;
      /**
       * Enables the "quickjs:encoding" module. Defaults to `true`.
       *
       * **Example**
       * ```ts
       * const context = new Context({
       *   yavascriptGlobals: false,
       *   modules: { "quickjs:encoding": false },
       * });
       * ```
       */
      "quickjs:encoding"?: boolean;
      /**
       * Enables the "quickjs:engine" module. Defaults to `true`.
       *
       * **Example**
       * ```ts
       * const context = new Context({
       *   yavascriptGlobals: false,
       *   modules: { "quickjs:engine": false },
       * });
       * ```
       */
      "quickjs:engine"?: boolean;
      /**
       * Enables the "quickjs:os" module. Defaults to `true`.
       *
       * **Example**
       * ```ts
       * const context = new Context({
       *   yavascriptGlobals: false,
       *   modules: { "quickjs:os": false },
       * });
       * ```
       */
      "quickjs:os"?: boolean;
      /**
       * Enables the "quickjs:std" module. Defaults to `true`.
       *
       * **Example**
       * ```ts
       * const context = new Context({
       *   yavascriptGlobals: false,
       *   modules: { "quickjs:std": false },
       * });
       * ```
       */
      "quickjs:std"?: boolean;
      /**
       * Enables the "quickjs:timers" module. Defaults to `true`.
       *
       * **Example**
       * ```ts
       * const context = new Context({
       *   modules: { "quickjs:timers": false },
       * });
       * ```
       */
      "quickjs:timers"?: boolean;
    };
  });

  /**
   * The `globalThis` object used by this context.
   *
   * You can add to or remove from it to change what is visible to the context.
   *
   * **Example**
   * ```ts
   * const context = new Context();
   * Object.assign(context.globalThis, { greeting: "hello" });
   * console.log(context.eval("greeting"));
   * ```
   */
  globalThis: typeof globalThis;

  /**
   * Runs code within the context and returns the result.
   *
   * @param code The code to run.
   *
   * > NOTE: This function will work even if you created the Context with option
   * > `eval: false` (which only disables eval *within* the context).
   *
   * **Example**
   * ```ts
   * const context = new Context();
   * const doubled = context.eval("[1, 2, 3].map((n) => n * 2)");
   * console.log(doubled);
   * ```
   */
  eval(code: string): any;
}


// ==========================================
// ------------------------------------------
// QuickJS APIs, which YavaScript builds upon
// ------------------------------------------
// ==========================================
interface ObjectConstructor {
  /**
   * Convert the specified value to a primitive value.
   *
   * The provided hint indicates a preferred return type, which may or may not
   * be respected by the engine.
   *
   * See the abstract operation "ToPrimitive" in the ECMAScript standard for
   * more info.
   */
  toPrimitive(
    input: any,
    hint: "string" | "number" | "default"
  ): string | number | bigint | boolean | undefined | symbol | null;

  /**
   * Returns a boolean indicating whether the specified value is a primitive value.
   */
  isPrimitive(input: any): boolean;
}

interface StringConstructor {
  /**
   * A no-op template literal tag.
   *
   * https://github.com/tc39/proposal-string-cooked
   */
  cooked(
    strings: readonly string[] | ArrayLike<string>,
    ...substitutions: any[]
  ): string;
}

/** npm: @suchipi/print@2.5.0. License: ISC */
/* (with some QuickJS-specific modifications) */

/*
Copyright (c) 2016-2022, John Gardner
Copyright (c) 2022 Lily Skye

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/**
 * Options for {@link inspect}.
 */
declare interface InspectOptions {
  /** Whether to display non-enumerable properties. Defaults to false. */
  all?: boolean;

  /** Whether to invoke getter functions. Defaults to false. */
  followGetters?: boolean;

  /** Whether to display the indexes of iterable entries. Defaults to false. */
  indexes?: boolean;

  /** Hide object details after 𝑁 recursions. Defaults to Infinity. */
  maxDepth?: number;

  /** If true, don't identify well-known symbols as `@@…`. Defaults to false. */
  noAmp?: boolean;

  /** If true, don't format byte-arrays as hexadecimal. Defaults to false. */
  noHex?: boolean;

  /** If true, don't display function source code. Defaults to false. */
  noSource?: boolean;

  /** Whether to show `__proto__` properties if possible. Defaults to false. */
  proto?: boolean;

  /** Whether to sort properties alphabetically. When false, properties are sorted by creation order. Defaults to false. */
  sort?: boolean;

  /** Options that control whether and how ANSI terminal escape sequences for colours should be added to the output. Defaults to false, meaning no colours. */
  colours?: boolean | 256 | 8 | InspectColours;

  /** Prefix string to use for indentation. Defaults to '\t'. */
  indent?: string;
}

declare interface InspectColours {
  off?: string | number;
  red?: string | number;
  grey?: string | number;
  green?: string | number;
  darkGreen?: string | number;
  punct?: string | number;
  keys?: string | number;
  keyEscape?: string | number;
  typeColour?: string | number;
  primitive?: string | number;
  escape?: string | number;
  date?: string | number;
  hexBorder?: string | number;
  hexValue?: string | number;
  hexOffset?: string | number;
  reference?: string | number;
  srcBorder?: string | number;
  srcRowNum?: string | number;
  srcRowText?: string | number;
  nul?: string | number;
  nulProt?: string | number;
  undef?: string | number;
  noExts?: string | number;
  frozen?: string | number;
  sealed?: string | number;
  regex?: string | number;
  string?: string | number;
  symbol?: string | number;
  symbolFade?: string | number;
  braces?: string | number;
  quotes?: string | number;
  empty?: string | number;
  dot?: string | number;
}

declare interface InspectFunction {
  /**
   * Generate a human-readable representation of a value.
   *
   * @param value - Value to inspect
   * @param options - Additional settings for refining output
   * @returns A string representation of `value`.
   */
  (value: any, options?: InspectOptions): string;

  /**
   * Generate a human-readable representation of a value.
   *
   * @param value - Value to inspect
   * @param key - The value's corresponding member name
   * @param options - Additional settings for refining output
   * @returns A string representation of `value`.
   */
  (value: any, key?: string | symbol, options?: InspectOptions): string;

  /**
   * A symbol which can be used to customize how an object gets printed.
   */
  custom: symbol;
}

/**
 * Generate a human-readable representation of a value.
 *
 * @param value - Value to inspect
 * @param key - The value's corresponding member name
 * @param options - Additional settings for refining output
 * @returns A string representation of `value`.
 */
declare var inspect: InspectFunction;

declare interface InspectCustomInputs {
  key: string | symbol;
  type: string;
  brackets: [string, string];
  oneLine: boolean;
  linesBefore: Array<string>;
  linesAfter: Array<string>;
  propLines: Array<string>;
  readonly tooDeep: boolean;
  indent: string;
  typeSuffix: string;
  opts: InspectOptions;
  colours: { [Key in keyof Required<InspectColours>]: string };
}

// Definitions for the quickjs:timers module and global timer functions

declare module "quickjs:timers" {
  export type Timer = { [Symbol.toStringTag]: "Timer" };

  /** Call the function func after delay ms. Return a handle to the timer. */
  export function setTimeout(func: (...args: any) => any, delay: number): Timer;

  /** Cancel a timer. */
  export function clearTimeout(handle: Timer): void;

  /** Call the function func repeatedly, with delay ms between each call. Return a handle to the timer. */
  export function setInterval(
    func: (...args: any) => any,
    delay: number
  ): Timer;

  /** Cancel an interval timer. */
  export function clearInterval(handle: Timer): void;

  /**
   * Asynchronous sleep. Returns a Promise that resolves after `delay_ms`
   * milliseconds. Intended for use with `await`.
   */
  export function sleepAsync(delay_ms: number): Promise<void>;
}

/** An opaque timer handle returned by setTimeout/setInterval */
declare type Timer = import("quickjs:timers").Timer;

/** Call the function func after delay ms. Return a handle to the timer. */
declare var setTimeout: typeof import("quickjs:timers").setTimeout;

/** Cancel a timer. */
declare var clearTimeout: typeof import("quickjs:timers").clearTimeout;

/** Call the function func repeatedly, with delay ms between each call. Return a handle to the timer. */
declare var setInterval: typeof import("quickjs:timers").setInterval;

/** Cancel an interval timer. */
declare var clearInterval: typeof import("quickjs:timers").clearInterval;

// Definitions for the quickjs:std module

/** An object representing a file handle. */
declare interface FILE {
  /**
   * Human-readable description of where this FILE points.
   *
   * If `target` is a number, the FILE was opened with fdopen, and `target` is
   * the fd. Otherwise, `target` will be an arbitrary string that describes the
   * file; it may be the absolute path to the file, the relative path to the
   * file at time of its opening, or some other string like "stdin" or
   * "tmpfile".
   *
   * You should *not* use this property for anything other than logging and
   * debugging. It is *only* provided for debugging and/or troubleshooting
   * purposes. The value of this property could change at any time when
   * upgrading QuickJS or yavascript, even if upgrading by a minor or patch
   * release.
   */
  target: string | number;

  /**
   * Close the file handle. Note that for files other than stdin/stdout/stderr,
   * the file will be closed automatically when the `FILE` object is
   * garbage-collected.
   */
  close(): void;

  /** Outputs the string with the UTF-8 encoding. */
  puts(...strings: Array<string>): void;

  /**
   * Formatted printf.
   *
   * The same formats as the standard C library `printf` are supported. Integer format types (e.g. `%d`) truncate the Numbers or BigInts to 32 bits. Use the `l` modifier (e.g. `%ld`) to truncate to 64 bits.
   */
  printf(fmt: string, ...args: Array<any>): void;

  /** Flush the buffered file. Wrapper for C `fflush`. */
  flush(): void;

  /** Sync the buffered file to disk. Wrapper for C `fsync`. */
  sync(): void;

  /**
   * Seek to a given file position (whence is `std.SEEK_*`).
   *
   * `offset` can be a number or a bigint.
   */
  seek(offset: number | bigint, whence: number): void;

  /** Return the current file position. */
  tell(): number;

  /** Return the current file position as a bigint. */
  tello(): bigint;

  /** Return true if end of file. */
  eof(): boolean;

  /** Return the associated OS handle. */
  fileno(): number;

  /** Read `length` bytes from the file to the ArrayBuffer `buffer` at byte position `position` (wrapper to the libc `fread`). Returns the number of bytes read, or `0` if the end of the file has been reached.  */
  read(buffer: ArrayBuffer, position: number, length: number): number;

  /** Write `length` bytes from the ArrayBuffer `buffer` at byte position `position` into the file (wrapper to the libc `fwrite`). Returns the number of bytes written. */
  write(buffer: ArrayBuffer, position: number, length: number): number;

  /**
   * Write this file into `target`, using a memory buffer of size `bufferSize`.
   *
   * If `limit` is specified, only that amount of bytes will be read and
   * written. Otherwise, data is read and written until this file reaches EOF.
   *
   * A `limit` of 0 is treated the same as not specifying a limit.
   *
   * Internally, this function uses libc `fread` and `fwrite` in a loop.
   *
   * Returns the number of bytes read and written.
   */
  writeTo(target: FILE, bufferSize: number, limit?: number): number;

  /**
   * Return the next line from the file, assuming UTF-8 encoding, excluding the trailing line feed or EOF.
   *
   * If the end of the file has been reached, then `null` will be returned instead of a string.
   *
   * Note: Although the trailing line feed has been removed, a carriage return (`\r`) may still be present.
   */
  getline(): string | null;

  /** Read `maxSize` bytes from the file and return them as a string assuming UTF-8 encoding. If `maxSize` is not present, the file is read up its end. */
  readAsString(maxSize?: number): string;

  /** Return the next byte from the file. Return -1 if the end of file is reached. */
  getByte(): number;

  /** Write one byte to the file. */
  putByte(value: number): void;

  /**
   * Set the buffering mode and buffer size for the file stream (wrapper to the libc `setvbuf()`).
   *
   * Note that unlike the libc setvbuf, the "buffer" argument is not supported, and therefore is not present.
   *
   * @param mode The buffering mode to use. It can be one of the following values: `std._IOFBF` for full buffering, `std._IOLBF` for line buffering, or `std._IONBF` for no buffering.
   * @param size The size to resize the internal in-memory buffer for this file to.
   */
  setvbuf(mode: number, size: number): void;
}

declare module "quickjs:std" {
  /**
   * Load the file `filename` and return it as a string assuming UTF-8 encoding.
   *
   * @param filename - The relative or absolute path to the file to load. Relative paths are resolved relative to the process's current working directory.
   */
  export function loadFile(filename: string): string;

  /**
   * Return a boolean indicating whether the provided value is a FILE object.
   *
   * @param value - The value to check.
   * @returns Whether the value was a `FILE` or not.
   */
  export function isFILE(value: any): boolean;

  /**
   * Open a file (wrapper to the libc `fopen()`).
   * Return the FILE object.
   *
   * @param filename - The relative or absolute path to the file to open. Relative paths are resolved relative to the process's current working directory.
   * @param flags - A string containing any combination of the characters 'r', 'w', 'a', '+', and/or 'b'.
   * @returns The opened FILE object.
   */
  export function open(filename: string, flags: string): FILE;

  /**
   * Open a process by creating a pipe (wrapper to the libc `popen()`).
   * Return the FILE object.
   *
   * @param command - The command line to execute. Gets passed via `/bin/sh -c`.
   * @param flags - A string containing any combination of the characters 'r', 'w', 'a', '+', and/or 'b'.
   * @returns The opened FILE object.
   */
  export function popen(command: string, flags: string): FILE;

  /**
   * Open a file from a file handle (wrapper to the libc `fdopen()`).
   * Return the FILE object.
   *
   * @param fd - The file handle to open.
   * @param flags - A string containing any combination of the characters 'r', 'w', 'a', '+', and/or 'b'.
   * @returns The opened FILE object.
   */
  export function fdopen(fd: number, flags: string): FILE;

  /**
   * Open a temporary file.
   * Return the FILE object.
   *
   * @returns The opened FILE object.
   */
  export function tmpfile(): FILE;

  /** Equivalent to `std.out.puts(str)`. */
  export function puts(...strings: Array<string>): void;

  /** Equivalent to `std.out.printf(fmt, ...args)` */
  export function printf(fmt: string, ...args: Array<any>): void;

  /** Equivalent to the libc sprintf(). */
  export function sprintf(fmt: string, ...args: Array<any>): void;

  /** Wrapper to the libc file stdin. */
  var in_: FILE;

  export { in_ as in };

  /** Wrapper to the libc file stdout. */
  export var out: FILE;

  /** Wrapper to the libc file stderr. */
  export var err: FILE;

  /** Constant for {@link FILE.seek}. Declares that pointer offset should be relative to the beginning of the file. See also libc `fseek()`. */
  export var SEEK_SET: number;

  /** Constant for {@link FILE.seek}. Declares that the offset should be relative to the current position of the FILE handle. See also libc `fseek()`. */
  export var SEEK_CUR: number;

  /** Constant for {@link FILE.seek}. Declares that the offset should be relative to the end of the file. See also libc `fseek()`. */
  export var SEEK_END: number;

  /** Constant for {@link FILE.setvbuf}. Declares that the buffer mode should be 'full buffering'. */
  export var _IOFBF: number;

  /** Constant for {@link FILE.setvbuf}. Declares that the buffer mode should be 'line buffering'. */
  export var _IOLBF: number;

  /** Constant for {@link FILE.setvbuf}. Declares that the buffer mode should be 'no buffering'. */
  export var _IONBF: number;

  /** The default buffer size for a buffered FILE. Useful for passing into {@link FILE.setvbuf}. */
  export var BUFSIZ: number;

  /** Return the value of the environment variable `name` or `undefined` if it is not defined. */
  export function getenv(name: string): string | undefined;

  /** Set the value of the environment variable `name` to the string `value`. */
  export function setenv(name: string, value: string): void;

  /** Delete the environment variable `name`. */
  export function unsetenv(name: string): void;

  /** Return an object containing the environment variables as key-value pairs. */
  export function getenviron(): { [key: string]: string | undefined };

  /**
   * Return the real user ID of the calling process.
   *
   * This function throws an error on windows, because windows doesn't support
   * the same uid/gid paradigm as Unix-like operating systems.
   */
  export function getuid(): number;

  /**
   * Return the effective user ID of the calling process.
   *
   * This function throws an error on windows, because windows doesn't support
   * the same uid/gid paradigm as Unix-like operating systems.
   */
  export function geteuid(): number;

  /**
   * Return the real group ID of the calling process.
   *
   * This function throws an error on windows, because windows doesn't support
   * the same uid/gid paradigm as Unix-like operating systems.
   */
  export function getgid(): number;

  /**
   * Return the effective group ID of the calling process.
   *
   * This function throws an error on windows, because windows doesn't support
   * the same uid/gid paradigm as Unix-like operating systems.
   */
  export function getegid(): number;

  /** The type of the object returned by {@link getpwuid}. */
  export interface PasswdEntry {
    name: string;
    passwd: string;
    uid: number;
    gid: number;
    gecos: string;
    dir: string;
    shell: string;
  }

  /**
   * Get information from the passwd file entry for the specified user id.
   *
   * See https://linux.die.net/man/3/getpwuid.
   *
   * This function throws an error on windows, because windows doesn't support
   * the same uid/gid paradigm as Unix-like operating systems.
   */
  export function getpwuid(id: number): PasswdEntry;

  /**
   * Parse `str` using a superset of JSON.parse. The following extensions are accepted:
   *
   * - Single line and multiline comments
   * - unquoted properties (ASCII-only Javascript identifiers)
   * - trailing comma in array and object definitions
   * - single quoted strings
   * - `\f` and `\v` are accepted as space characters
   * - leading plus in numbers
   * - octal (0o prefix) and hexadecimal (0x prefix) numbers
   */
  export function parseExtJSON(str: string): any;

  /**
   * A wrapper around the standard C [strftime](https://en.cppreference.com/w/c/chrono/strftime).
   * Formats a time/date into a format as specified by the user.
   *
   * @param maxBytes - The number of bytes to allocate for the string that will be returned
   * @param format - Format string, using `%`-prefixed sequences as found in [this table](https://en.cppreference.com/w/c/chrono/strftime#Format_string).
   * @param time - The Date object (or unix timestamp, in ms) to render.
   */
  export function strftime(
    maxBytes: number,
    format: string,
    time: Date | number
  ): string;
}

// Definitions for the quickjs:os module

declare module "quickjs:os" {
  /**
   * Open a file handle. Returns a number; the file descriptor.
   *
   * @param filename - The path to the file to open.
   * @param flags - Numeric flags that set the mode to use when opening the file. See `os.O_*`
   * @param mode - Octal access mask. Defaults to 0o666.
   */
  export function open(filename: string, flags: number, mode?: number): number;

  /** POSIX open flag, used in {@link open}. */
  export var O_RDONLY: number;
  export var O_WRONLY: number;
  export var O_RDWR: number;
  export var O_APPEND: number;
  export var O_CREAT: number;
  export var O_EXCL: number;
  export var O_TRUNC: number;
  export var O_BINARY: number;
  export var O_TEXT: number;

  /** Close the file with descriptor `fd`. */
  export function close(fd: number): void;

  interface OsSeek {
    (fd: number, offset: number, whence: number): number;
    (fd: number, offset: bigint, whence: number): bigint;
  }

  export var seek: OsSeek;

  export function read(
    fd: number,
    buffer: ArrayBuffer,
    offset: number,
    length: number
  ): number;
  export function write(
    fd: number,
    buffer: ArrayBuffer,
    offset: number,
    length: number
  ): number;
  export function isatty(fd: number): boolean;
  export function ttyGetWinSize(fd: number): null | [number, number];
  export function ttySetRaw(fd: number): void;
  export function remove(filename: string): void;
  export function rename(oldname: string, newname: string): void;
  export function realpath(path: string): string;
  export function getcwd(): string;
  export function chdir(path: string): void;
  export function mkdir(path: string, mode?: number): void;
  export function readdir(path: string): Array<string>;

  export type Stats = {
    dev: number;
    ino: number;
    mode: number;
    nlink: number;
    uid: number;
    gid: number;
    rdev: number;
    size: number;
    blocks: number;
    atime: number;
    mtime: number;
    ctime: number;
  };

  export function stat(path: string): Stats;
  export function lstat(path: string): Stats;

  /* st_mode constants */
  export var S_IFMT: number;
  export var S_IFIFO: number;
  export var S_IFCHR: number;
  export var S_IFDIR: number;
  export var S_IFBLK: number;
  export var S_IFREG: number;
  export var S_IFSOCK: number;
  export var S_IFLNK: number;
  export var S_ISGID: number;
  export var S_ISUID: number;
  export var S_IRWXU: number;
  export var S_IRUSR: number;
  export var S_IWUSR: number;
  export var S_IXUSR: number;
  export var S_IRWXG: number;
  export var S_IRGRP: number;
  export var S_IWGRP: number;
  export var S_IXGRP: number;
  export var S_IRWXO: number;
  export var S_IROTH: number;
  export var S_IWOTH: number;
  export var S_IXOTH: number;

  export function utimes(path: string, atime: number, mtime: number): void;
  export function symlink(target: string, linkpath: string): void;
  export function readlink(path: string): string;
  /**
   * Register a function to be called when `fd` becomes readable.
   * Pass `null` as `func` to unregister.
   *
   * **Windows:** only `fd === 0` (stdin) is supported. Calling with any
   * other fd throws — the underlying Windows event loop has no plumbing
   * for arbitrary fds (it special-cases the stdin console handle), so
   * registering would silently never fire.
   */
  export function setReadHandler(fd: number, func: null | (() => void)): void;
  /**
   * Register a function to be called when `fd` becomes writable.
   * Pass `null` as `func` to unregister.
   *
   * **Windows:** not supported — the Windows event loop has no plumbing
   * for write readiness on any fd. Calling this with a non-`null`
   * handler throws on Windows.
   */
  export function setWriteHandler(fd: number, func: null | (() => void)): void;

  export function signal(
    signal: number,
    func: null | undefined | (() => void)
  ): void;

  /* Signal constants */
  export var SIGINT: number;
  export var SIGABRT: number;
  export var SIGFPE: number;
  export var SIGILL: number;
  export var SIGSEGV: number;
  export var SIGTERM: number;
  export var SIGQUIT: number;
  export var SIGPIPE: number;
  export var SIGALRM: number;
  export var SIGUSR1: number;
  export var SIGUSR2: number;
  export var SIGCHLD: number;
  export var SIGCONT: number;
  export var SIGSTOP: number;
  export var SIGTSTP: number;
  export var SIGTTIN: number;
  export var SIGTTOU: number;

  export function kill(pid: number, sig: number): void;

  export type ExecOptions = {
    block?: boolean;
    usePath?: boolean;
    file?: string;
    cwd?: string;
    stdin?: number | FILE;
    stdout?: number | FILE;
    stderr?: number | FILE;
    env?: { [key: string | number]: string | number | boolean };
    uid?: number;
    gid?: number;
  };

  export function exec(args: Array<string>, options?: ExecOptions): number;

  /** Return the current process ID. */
  export function getpid(): number;

  export function waitpid(pid: number, options?: number): [number, number];

  export var WNOHANG: number;
  export var WUNTRACED: number;

  export function WEXITSTATUS(status: number): number;
  export function WTERMSIG(status: number): number;
  export function WSTOPSIG(status: number): number;
  export function WIFEXITED(status: number): boolean;
  export function WIFSIGNALED(status: number): boolean;
  export function WIFSTOPPED(status: number): boolean;
  export function WIFCONTINUED(status: number): boolean;

  export function dup(fd: number): number;
  export function dup2(oldfd: number, newfd: number): number;
  export function pipe(): [number, number];
  export function sleep(delay_ms: number): void;

  /**
   * Return a timestamp in milliseconds with more precision than
   * `Date.now()`. The time origin is unspecified and is normally not
   * impacted by system clock adjustments.
   */
  export function now(): number;

  // keep in sync with quickjs-os.c
  export var platform:
    | "win32"
    | "darwin"
    | "emscripten"
    | "wasm"
    | "freebsd"
    | "linux"
    | "unknown";

  export type StructuredClonable =
    | string
    | number
    | boolean
    | null
    | undefined
    | Boolean
    | String
    | Date
    | RegExp
    | ArrayBuffer
    | Int8Array
    | Uint8Array
    | Uint8ClampedArray
    | Int16Array
    | Uint16Array
    | Int32Array
    | Uint32Array
    | Float32Array
    | Float64Array
    | BigInt64Array
    | BigUint64Array
    | DataView
    | Array<StructuredClonable>
    | SharedArrayBuffer
    | { [key: string | number]: StructuredClonable };

  export class Worker {
    /**
     * Create a Worker which runs the module at `moduleFilename`.
     *
     * If `options.overrideCode` is present, the Worker instead runs a synthetic
     * module with filename `moduleFilename` and source code
     * `options.overrideCode` (JS source code string). In this case,
     * `moduleFilename` is not read from disk and is only used as the module's
     * assigned filename for import.meta, module resolution, etc.
     *
     * If `options.initialData` is present, it'll be available within the worker
     * as the static `initialData` property on the Worker constructor.
     */
    constructor(
      moduleFilename: string,
      options?: {
        overrideCode?: string;
        initialData?: StructuredClonable;
      }
    );

    /**
     * If accessed within a Worker, and the Worker was constructed with
     * non-undefined `initialData`, then this will be a structured clone of that
     * initial data.
     *
     * Outside of a worker, this is always `undefined`.
     */
    static initialData: StructuredClonable;

    /**
     * Worker-side communication channel back to the parent context that invoked
     * it (ie. the main thread).
     */
    static parent: Pick<Worker, "postMessage" | "onmessage">;

    postMessage(msg: StructuredClonable): void;
    /**
     * Terminate the worker thread. Equivalent to setting `onmessage` to `null`.
     */
    terminate(): void;
    onmessage: null | ((event: { data: StructuredClonable }) => void);
    /**
     * Fires on the parent side whenever an uncaught exception escapes
     * anywhere in the worker: top-level errors at startup, the worker's
     * global `onmessage` throwing, timer / I/O / signal callbacks
     * throwing, microtask rejections, and unhandled promise rejections.
     *
     * The event is a plain object shaped like a WHATWG `ErrorEvent`
     * (minus `colno`, which this event does not surface):
     *
     * - `message` — the error's message, or `String(reason)` for a
     *   non-Error throw.
     * - `filename` — from the error's `fileName` own-prop when present,
     *   otherwise the worker's entry-module filename.
     * - `lineno` — from the error's `lineNumber` own-prop, otherwise `0`.
     * - `error` — a real `Error` instance when the worker threw an
     *   Error (one of the ten recognized classes: `Error`, `TypeError`,
     *   `RangeError`, `SyntaxError`, `ReferenceError`, `URIError`,
     *   `EvalError`, `AggregateError`, `SuppressedError`,
     *   `InternalError`, with user
     *   subclasses reified to base `Error` with `.name` preserved).
     *   `null` when the thrown value was not an Error.
     *
     * Cycles and shared references in the error graph (e.g.
     *   `err.cause === err`, or shared nodes inside
     *   `AggregateError.errors[]`) are preserved, matching the HTML
     *   structured-clone algorithm.
     *
     * A handler assigned same-tick as `new Worker(...)` is guaranteed
     * to be in place before any error dispatch: the parent's event
     * loop cannot drain and dispatch error-pipe messages until the
     * current synchronous tick finishes, and the error-port
     * registration (on which dispatch is gated) happens synchronously
     * in the Worker ctor. Cross-tick late assignment (`setTimeout(() =>
     * w.onerror = fn, 100)`) is still racy with any error that fires
     * before the timeout — such errors fall through to the stderr
     * fallback. When `onerror` is unset, errors print to stderr in the
     * same format as an uncaught exception would.
     */
    onerror:
      | null
      | ((event: {
          message: string;
          filename: string;
          lineno: number;
          error: Error | null;
        }) => void);
  }

  /**
   * An opaque wrapper around a Win32 HANDLE.
   *
   * Win32Handle objects cannot be created directly from JavaScript code.
   * They are created by native functions like {@link CreateProcess}.
   *
   * On non-Windows platforms, this class exists but no instances will ever
   * be created.
   */
  export class Win32Handle {
    private constructor();
    readonly [Symbol.toStringTag]: "Win32Handle";
  }

  export type CreateProcessOptions = {
    /** The name of the module to be executed (maps to lpApplicationName). */
    moduleName?: string;

    /** Process creation flags (maps to dwCreationFlags). */
    flags?: number;

    /** The working directory of the new process. */
    cwd?: string;

    /** Environment variables for the new process. If not specified, the parent's environment is inherited. Values must be strings. */
    env?: { [key: string]: string };

    /** FILE object or file descriptor number to use for the child's stdin. */
    stdin?: FILE | number;

    /** FILE object or file descriptor number to use for the child's stdout. */
    stdout?: FILE | number;

    /** FILE object or file descriptor number to use for the child's stderr. */
    stderr?: FILE | number;
  };

  export type CreateProcessResult = {
    /** The process ID of the newly created process. */
    pid: number;

    /** A Win32Handle for the process. */
    processHandle: Win32Handle;

    /** The thread ID of the primary thread of the newly created process. */
    tid: number;

    /** A Win32Handle for the primary thread. */
    threadHandle: Win32Handle;
  };

  /**
   * Create a new process using the Win32 `CreateProcessW` API.
   *
   * @param commandLine - The command line to execute.
   * @param options - Optional settings for module name, flags, cwd, env, and stdio redirection.
   * @returns An object with `pid`, `processHandle`, `tid`, and `threadHandle`.
   *
   * NOTE: this function is only present on windows
   */
  export var CreateProcess:
    | undefined
    | ((
        commandLine: string | null,
        options?: CreateProcessOptions
      ) => CreateProcessResult);

  /**
   * Wait for a Win32 handle to be signaled (wrapper for Win32 `WaitForSingleObject`).
   *
   * @param handle - The handle to wait on.
   * @param timeoutMs - Timeout in milliseconds. Defaults to `Infinity` (INFINITE). Pass `Infinity` to wait indefinitely.
   * @returns One of the `WAIT_*` constants.
   *
   * NOTE: this function is only present on windows
   */
  export var WaitForSingleObject:
    | undefined
    | ((handle: Win32Handle, timeoutMs?: number) => number);

  /**
   * Retrieve the exit code of a process (wrapper for Win32 `GetExitCodeProcess`).
   *
   * @param handle - A process handle.
   * @returns The exit code of the process.
   *
   * NOTE: this function is only present on windows
   */
  export var GetExitCodeProcess: undefined | ((handle: Win32Handle) => number);

  /**
   * Terminate a process (wrapper for Win32 `TerminateProcess`).
   *
   * @param handle - A process handle.
   * @param exitCode - The exit code to assign to the process.
   *
   * NOTE: this function is only present on windows
   */
  export var TerminateProcess:
    | undefined
    | ((handle: Win32Handle, exitCode: number) => void);

  /**
   * Close a Win32 handle. The handle will automatically be closed when the
   * Win32Handle object is garbage-collected, but it's safe to close it
   * yourself as well; a handle that has already been closed will not be
   * closed again during garbage collection.
   *
   * @param handle - The handle to close.
   *
   * NOTE: this function is only present on windows
   */
  export var CloseHandle: undefined | ((handle: Win32Handle) => void);

  export type CreatePipeOptions = {
    /** Whether the pipe handles should be inheritable. Defaults to true. */
    inheritHandle?: boolean;
  };

  export type CreatePipeResult = {
    /** The read end of the pipe (a FILE object opened in binary read mode). */
    readEnd: FILE;

    /** The write end of the pipe (a FILE object opened in binary write mode). */
    writeEnd: FILE;
  };

  /**
   * Create an anonymous pipe (wrapper for Win32 `CreatePipe`).
   *
   * Returns FILE objects for both ends of the pipe. The read end is opened in
   * binary read mode ("rb") and the write end in binary write mode ("wb").
   * You can use all standard FILE methods (readAsString, getline, puts, write,
   * read, close, etc.) on the returned objects.
   *
   * @param options - Optional settings. `inheritHandle` defaults to true.
   * @returns An object with `readEnd` and `writeEnd` FILE properties.
   *
   * NOTE: this function is only present on windows
   */
  export var CreatePipe:
    | undefined
    | ((options?: CreatePipeOptions) => CreatePipeResult);

  /* Win32-specific constants */

  /**
   * Win32 wait result constant: the object was signaled.
   *
   * NOTE: this property is only present on windows
   */
  export var WAIT_OBJECT_0: number | undefined;

  /**
   * Win32 wait result constant: the object was an abandoned mutex.
   *
   * NOTE: this property is only present on windows
   */
  export var WAIT_ABANDONED: number | undefined;

  /**
   * Win32 wait result constant: the wait timed out.
   *
   * NOTE: this property is only present on windows
   */
  export var WAIT_TIMEOUT: number | undefined;

  /**
   * Win32 wait result constant: the function call failed.
   *
   * NOTE: this property is only present on windows
   */
  export var WAIT_FAILED: number | undefined;

  /* access() constants */
  export var R_OK: number;
  export var W_OK: number;
  export var X_OK: number;
  export var F_OK: number;

  export function access(path: string, accessMode: number): void;
  export function execPath(): string;
  export function chmod(path: string, mode: number): void;
  export function gethostname(): string;
}

/**
 * The `"quickjs:cmdline"` module provides access to command line arguments
 * and process exit code management.
 *
 * It can be imported using either of these forms:
 * ```js
 * import * as cmdline from "quickjs:cmdline";
 * import { scriptArgs, exit } from "quickjs:cmdline";
 * ```
 */
declare module "quickjs:cmdline" {
  /**
   * Returns the command line arguments. The first element is the script name.
   *
   * Note: The global `scriptArgs` variable is also available and is the
   * preferred way to access command line arguments.
   */
  export function getScriptArgs(): Array<string>;

  /**
   * Terminates the process with the given exit code.
   *
   * If no exit code is provided, uses the value set by `setExitCode`, or 0 if
   * one hasn't been set.
   */
  export function exit(exitCode?: number): never;

  /**
   * Gets the current exit code (as set by setExitCode or errors).
   */
  export function getExitCode(): number;

  /**
   * Sets the exit code to be returned when the process exits. This does not
   * terminate the process; it only sets the code that will be returned when the
   * process eventually exits.
   *
   * If a future `exit` call receives an exitCode argument, the value set by
   * setExitCode will be ignored.
   */
  export function setExitCode(exitCode: number): void;
}

/**
 * Provides the command line arguments. The first element is the script name.
 *
 * This is a global variable that is set by the host environment.
 */
declare var scriptArgs: Array<string>;

/**
 * An object which lets you configure the module loader (import/export/require).
 * You can change these properties to add support for importing new filetypes.
 */
interface ModuleDelegate {
  /**
   * A list of filetype extensions that may be omitted from an import specifier
   * string.
   *
   * Defaults to `[".js"]`. You can add more strings to this array to
   * make the engine search for additional files when resolving a
   * require/import.
   *
   * See the doc comment on {@link require} for more information.
   *
   * NOTE: If you add a new extension to this array, you will likely also want
   * to add to {@link compilers}.
   */
  searchExtensions: Array<string>;

  /**
   * User-defined functions which will handle getting the JavaScript code
   * associated with a module.
   *
   * Keys in this object can take one of two forms:
   * - `".ext"` (with a leading dot) — matches files whose name ends with
   *   `.ext`. Selected by file extension during normal module loading.
   * - `"type"` (no leading dot) — matches imports written with
   *   `import x from "..." with { type: "<key>" }`. Selected by
   *   import-attributes type, regardless of file extension.
   *
   * The value for each property is a function which receives (1) the filepath
   * to a module, (2) that file's content as a UTF-8 string, and (3) the
   * import attributes object (or `undefined` when no `with { ... }` clause was
   * used). The function should return a string containing JavaScript code that
   * corresponds to that module. In most cases, these functions will compile
   * the contents of the file from one format into JavaScript.
   *
   * The function does not have to use the second 'content' argument it
   * receives (ie. when loading binary files).
   *
   * By adding to this object, you can make it possible to import non-js
   * filetypes; compile-to-JS languages like JSX, TypeScript, and CoffeeScript
   * can be compiled at import time, and asset files like .txt files or .png
   * files can be converted into an appropriate data structure at import time.
   *
   * `compilers["json"]` is pre-registered, which turns JSON file content
   * into a JS module source of the form
   * `export default JSON.parse(<escaped content>);`. To make `.json`
   * files load by extension alone (without `with { type: "json" }`),
   * register the same loader under the dot-prefixed key:
   *
   * ```js
   * ModuleDelegate.compilers[".json"] = ModuleDelegate.compilers["json"];
   * ```
   *
   * `compilers["json5"]` is also pre-registered, which turns JSON5
   * file content (JSON with comments, trailing commas, unquoted keys,
   * single quotes, NaN/Infinity, `.N` decimals, multi-line strings,
   * and the `\v` escape) into a JS module source that parses the
   * content via `std.parseExtJSON`. It matches
   * `import x from "..." with { type: "json5" }` by default.
   *
   * As an example, to make it possible to import .txt files, you might do:
   * ```js
   * import * as std from "std";
   *
   * ModuleDelegate.compilers[".txt"] = (filename, content) => {
   *   return `export default ${JSON.stringify(content)}`;
   * }
   * ```
   * (leveraging `JSON.stringify`'s ability to escape quotes).
   *
   * Then, later in your code, you can do:
   * ```js
   * import names from "./names.txt";
   * ```
   *
   * And `names` will be a string containing the contents of names.txt.
   *
   * NOTE: When adding a dot-prefixed key, you may also wish to add to
   * {@link searchExtensions}.
   */
  compilers: {
    [key: string]: (
      filename: string,
      content: string,
      attributes?: Record<string, string>
    ) => string;
  };

  /**
   * An Array containing the names of all the built-in modules, such as
   * "quickjs:std", "quickjs:bytecode", etc.
   *
   * `quickjs:engine`'s `defineBuiltinModule` function adds to the end of this
   * array.
   */
  builtinModuleNames: Array<string>;

  /**
   * Resolves a require/import request from `fromFile` into a canonicalized
   * path.
   *
   * `attributes` is the import-attributes object (passed via the
   * `with { ... }` clause), or `undefined` when no `with` clause was used.
   *
   * To change native module resolution behavior, replace this function with
   * your own implementation. Note that you must handle
   * `ModuleDelegate.searchExtensions` yourself in your replacement
   * implementation.
   */
  resolve(
    name: string,
    fromFile: string,
    attributes?: Record<string, string>
  ): string;

  /**
   * Reads the contents of the given resolved module name into a string.
   *
   * `attributes` is the import-attributes object (passed via the
   * `with { ... }` clause), or `undefined` when no `with` clause was used.
   *
   * To change native module loading behavior, replace this function with your
   * own implementation. Note that you must handle `ModuleDelegate.compilers`
   * yourself in your replacement implementation.
   */
  read(modulePath: string, attributes?: Record<string, string>): string;
}

interface RequireFunction {
  /**
   * Synchronously import a module.
   *
   * `source` will be resolved relative to the calling file.
   *
   * If `source` does not have a file extension, and a file without an extension
   * cannot be found, the engine will check for files with the extensions in
   * {@link ModuleDelegate.searchExtensions}, and use one of those if present.
   * This behavior also happens when using normal `import` statements.
   *
   * For example, if you write:
   *
   * ```js
   * import something from "./somewhere";
   * ```
   *
   * but there's no file named `somewhere` in the same directory as the file
   * where that import appears, and `ModuleDelegate.searchExtensions` is the
   * default value:
   *
   * ```js
   * [".js"]
   * ```
   *
   * then the engine will look for `somewhere.js`. If that doesn't exist, the
   * engine will look for `somewhere/index.js`. If *that* doesn't exist, an
   * error will be thrown.
   *
   * If you add more extensions to `ModuleDelegate.searchExtensions`, then the
   * engine will use those, too. It will search in the same order as the strings
   * appear in the `ModuleDelegate.searchExtensions` array.
   *
   * The optional `options` argument matches the second argument of
   * dynamic `import()`. Its `with` property carries import attributes,
   * eg `require("./data.json", { with: { type: "json" } })`.
   */
  (source: string, options?: { with?: Record<string, string> }): any;

  /**
   * Resolves the normalized path to a modules, relative to the calling file.
   *
   * The optional `options` argument matches the shape of dynamic
   * `import()`'s second argument. Its `with` property carries import
   * attributes which are passed through to `ModuleDelegate.resolve`.
   */
  resolve: (
    source: string,
    options?: { with?: Record<string, string> }
  ) => string;
}

// global added by QJMS_InitContext
declare var require: RequireFunction;

// gets set per-module by QJMS_SetModuleImportMeta
interface ImportMeta {
  /**
   * A URL representing the current module.
   *
   * Usually starts with `file://`.
   */
  url: string;

  /**
   * Whether the current module is the "main" module, meaning that it is the
   * entrypoint file that's been loaded, or, in other terms, the first
   * user-authored module that's been loaded.
   */
  main: boolean;

  /**
   * Equivalent to `globalThis.require`. Provided for compatibility with tools
   * that can leverage a CommonJS require function via `import.meta.require`.
   */
  require: RequireFunction;

  /**
   * Resolves a module specifier based on the current module's path.
   *
   * Equivalent to `globalThis.require.resolve`.
   *
   * Behaves similarly to [the browser
   * import.meta.resolve](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import.meta/resolve),
   * but it does not ensure that the returned string is a valid URL, because it
   * delegates directly to {@link ModuleDelegate.resolve} to resolve the name.
   * If you want this to return URL strings, change `ModuleDelegate.resolve` and
   * `ModuleDelegate.read` to work with URL strings.
   */
  resolve: RequireFunction["resolve"];

  /**
   * The `with { ... }` clause that was used to import this module, if any.
   *
   * - `undefined` when the module was imported without a `with` clause.
   * - An object whose enumerable own properties are the attribute key/value
   *   pairs from the `with` clause when one was used. The object is
   *   non-extensible, and each own property is non-writable and
   *   non-configurable.
   * - The `attributes` property itself is also non-writable and
   *   non-configurable.
   *
   * The undefined-vs-empty-object distinction is meaningful: a module body can
   * tell whether it was imported with a (possibly empty) attribute clause vs
   * no clause at all.
   */
  attributes: Record<string, string> | undefined;
}

declare module "quickjs:engine" {
  /**
   * Return whether the provided resolved module path is set as the main module.
   *
   * In other words, return what the value of `import.meta.main` would be within
   * the module.
   *
   * The main module can be set via {@link setMainModule}.
   */
  export function isMainModule(resolvedFilepath: string): boolean;

  /**
   * Set the main module to the module with the provided resolved path.
   *
   * This will affect the value of `import.meta.main` for modules loaded in the
   * future, but it will NOT retroactively change the value of
   * `import.meta.main` in existing already-loaded modules.
   */
  export function setMainModule(resolvedFilepath: string): void;

  /**
   * Evaluate the string `code` as a script (global eval).
   *
   * @param code - The code to evaluate.
   * @param options - An optional object containing the following optional properties:
   * @property backtraceBarrier - Boolean (default = false). If true, error backtraces do not list the stack frames below the evalScript.
   * @property filename - String (default = "<evalScript>"). The filename to associate with the code being executed.
   * @property async - Boolean (default = false). If true, `await` is accepted at the top level of `code` and a Promise is returned.
   * @returns The result of the evaluation. If `async` is true, a Promise.
   */
  export function evalScript(
    code: string,
    options?: {
      backtraceBarrier?: boolean;
      filename?: string;
      async?: boolean;
    }
  ): any;

  /**
   * Evaluate the file `filename` as a script (global eval).
   *
   * @param filename - The relative or absolute path to the file to load. Relative paths are resolved relative to the process's current working directory.
   * @returns The result of the evaluation.
   */
  export function runScript(filename: string): any;

  /**
   * Evaluate the file `filename` as a module. Effectively a synchronous dynamic `import()`.
   *
   * @param filename - The relative or absolute path to the file to import. Relative paths are resolved relative to the file calling `importModule`, or `basename` if present.
   * @param basename - If present and `filename` is a relative path, `filename` will be resolved relative to this basename.
   * @param options - Mirrors the second argument of dynamic `import()`. Its `with` property carries import attributes, eg `{ with: { type: "json" } }`.
   * @returns The result of the evaluation (module namespace object).
   */
  export function importModule(
    filename: string,
    basename?: string,
    options?: { with?: Record<string, string> }
  ): { [key: string]: any };

  /**
   * Return the resolved path to a module.
   *
   * @param filename - The relative or absolute path to the file to import. Relative paths are resolved relative to the file calling `importModule`, or `basename` if present.
   * @param basename - If present and `filename` is a relative path, `filename` will be resolved relative to this basename.
   * @param options - Mirrors the second argument of dynamic `import()`. Its `with` property carries import attributes, eg `{ with: { type: "json" } }`.
   * @returns The resolved module path.
   */
  export function resolveModule(
    filename: string,
    basename?: string,
    options?: { with?: Record<string, string> }
  ): string;

  /**
   * Read the script of module filename from an active stack frame, then return it as a string.
   *
   * If there isn't a valid filename for the specified stack frame, an error will be thrown.
   *
   * @param stackLevels - How many levels up the stack to search for a filename. Defaults to 0, which uses the current stack frame.
   */
  export function getFileNameFromStack(stackLevels?: number): string;

  /**
   * A single stack frame captured by {@link getStackFrames}.
   *
   * A frame either has a source location (all three of `fileName`,
   * `lineNumber`, and `columnNumber` are present) or has none (all three are
   * `null`). A frame has no location when it is a native (C) frame, or comes
   * from code compiled without debug information. The two cases never mix, so
   * checking any one field narrows the other two:
   *
   * ```js
   * for (const frame of getStackFrames()) {
   *   if (frame.fileName !== null) {
   *     // fileName, lineNumber, and columnNumber are all non-null here
   *   }
   * }
   * ```
   *
   * `lineNumber` and `columnNumber` are 1-based, matching the values used by
   * the stack frame mapper (see {@link setStackFrameMapper}) and by an
   * Error's `lineNumber` / `columnNumber` own properties.
   */
  export type StackFrame =
    | {
        fileName: string;
        lineNumber: number;
        columnNumber: number;
      }
    | {
        fileName: null;
        lineNumber: null;
        columnNumber: null;
      };

  /**
   * Capture the current call stack as an array of {@link StackFrame} objects,
   * ordered from the innermost (most recent) frame outward.
   *
   * Frame locations are passed through the registered stack frame mapper (see
   * {@link setStackFrameMapper}), so a frame's `fileName` / `lineNumber` /
   * `columnNumber` match what an Error thrown at that point would report.
   *
   * Frames beyond a `backtraceBarrier` (see {@link evalScript}) are not
   * included, exactly as they are omitted from `error.stack`.
   *
   * @param skip - How many innermost frames to omit from the result. Defaults
   *   to 0, which starts at the caller of `getStackFrames`.
   */
  export function getStackFrames(skip?: number): StackFrame[];

  /**
   * Returns true if `target` is a module namespace object.
   */
  export function isModuleNamespace(target: any): boolean;

  /**
   * Create a virtual built-in module whose exports consist of the own
   * enumerable properties of `obj`.
   */
  export function defineBuiltinModule(
    name: string,
    obj: { [key: string]: any }
  ): void;

  /**
   * An object which lets you configure the module loader (import/export/require).
   * You can change these properties to add support for importing new filetypes.
   */
  export const ModuleDelegate: ModuleDelegate;

  /**
   * Manually invoke the cycle removal algorithm (garbage collector).
   *
   * The cycle removal algorithm is automatically started when needed, so this
   * function is useful in case of specific memory constraints or for testing.
   */
  export function gc(): void;

  /**
   * A callback that translates the location of a stack frame as an error's
   * backtrace is built. See {@link setStackFrameMapper} for details.
   *
   * `line` and `column` are 1-based, both for the values passed in and for the
   * values returned. To change the frame's location, return an object
   * containing all three of `filename`, `line`, and `column`. Return `null` or
   * `undefined` (or an object missing any field) to leave the location
   * unchanged.
   */
  export type StackFrameMapper = (
    filename: string,
    line: number,
    column: number
  ) => { filename: string; line: number; column: number } | null | undefined;

  /**
   * Register a callback that translates the location of each stack frame as an
   * error's backtrace is built. This is the hook to use for source-map support:
   * the engine itself knows nothing about source maps, so the callback is where
   * you map a compiled `(filename, line, column)` back to its original source
   * location.
   *
   * The callback is invoked once per frame while the backtrace string is being
   * assembled. The location it returns is used both in the human-readable
   * `error.stack` string AND in the `fileName` / `lineNumber` / `columnNumber`
   * own properties set on the error object, so they stay consistent.
   *
   * `line` and `column` are 1-based, both for the values passed to the callback
   * and for the values it returns.
   *
   * To take effect, the callback must return an object containing all three of
   * `filename`, `line`, and `column`. If it instead returns `null` or
   * `undefined`, returns an object missing any of those fields, returns a
   * non-object, or throws, the frame's original location is kept unchanged (a
   * thrown error is swallowed rather than propagated into backtrace
   * construction).
   *
   * Only one mapper can be registered at a time; registering a new one replaces
   * the previous one. Pass `null` or `undefined` to unregister, restoring the
   * default behavior of reporting compiled locations.
   *
   * While the mapper is running, it is temporarily disabled for any error thrown
   * from within it, so an error thrown inside the mapper will not recurse
   * infinitely; that nested error's backtrace simply reports its original
   * (unmapped) locations.
   *
   * @param mapper - The translation callback, or `null`/`undefined` to unregister.
   */
  export function setStackFrameMapper(
    mapper: StackFrameMapper | null | undefined
  ): void;

  /**
   * Return the stack frame mapper currently registered via
   * {@link setStackFrameMapper}, or `null` if none is registered.
   *
   * This is useful for composing mappers: read the existing one, then register
   * a new mapper that adds your own behavior and delegates to the previous one.
   *
   * ```js
   * const previous = getStackFrameMapper();
   * setStackFrameMapper((filename, line, column) => {
   *   const mapped = previous ? previous(filename, line, column) : null;
   *   const location = mapped ?? { filename, line, column };
   *   // ...apply your own additional adjustments to `location`...
   *   return location;
   * });
   * ```
   */
  export function getStackFrameMapper(): StackFrameMapper | null;

  /**
   * Format a value for debugging using QuickJS's built-in C-level printer.
   *
   * This is a parallel formatter to {@link inspect} — it uses the engine's
   * internal pretty-printer (the same one used by `JS_PrintValue` in the C
   * API). It can show things JS cannot, like the closure variables of a
   * function (with `showClosure: true`), and runs without invoking any
   * user-defined `toString` / `[Symbol.toPrimitive]` / Proxy traps in
   * `rawDump` mode.
   *
   * For typical script-level value formatting, `inspect()` is usually a
   * better choice — it is more configurable, handles cycles via path
   * strings, and supports custom formatters via `inspect.custom`. Reach for
   * `formatValue` when you need C-level introspection (closure access) or
   * a side-effect-free dump (`rawDump`).
   *
   * @param value - The value to format.
   * @param options - Optional formatting options.
   * @property showHidden - Boolean (default = false). Include non-enumerable properties.
   * @property showClosure - Boolean (default = false). For functions, include closure variables and home object.
   * @property rawDump - Boolean (default = false). Skip toString/toPrimitive/Proxy traps; print raw structural info.
   * @property maxDepth - Number (default = 2, hard cap = 8). Recursion limit. Set to 0 for the hard cap.
   * @property maxStringLength - Number (default = 1000). Truncate strings longer than this. Set to 0 for unlimited.
   * @property maxItemCount - Number (default = 100). Truncate arrays/objects with more entries than this. Set to 0 for unlimited.
   * @returns The formatted string.
   */
  export function formatValue(
    value: any,
    options?: {
      showHidden?: boolean;
      showClosure?: boolean;
      rawDump?: boolean;
      maxDepth?: number;
      maxStringLength?: number;
      maxItemCount?: number;
    }
  ): string;

  /**
   * Format a value using QuickJS's built-in C-level printer and write the
   * result directly to stdout (no trailing newline).
   *
   * Equivalent in spirit to `process.stdout.write(formatValue(value))`,
   * but writes directly via the C API without building a JS string in
   * between. Provided for API parity with the underlying `JS_PrintValue`
   * C API.
   *
   * The `__` prefix marks this as a direct mirror of upstream QuickJS's
   * `std.__printObject` API (relocated to `quickjs:engine` in this fork
   * because the fork has been moving `std` helpers to `engine`).
   *
   * @param value - The value to print.
   */
  export function __printObject(value: any): void;
}

declare module "quickjs:bytecode" {
  /**
   * Convert the module or script in the specified file into bytecode.
   *
   * When converted back to a value, it will be a function.
   */
  export function fromFile(
    path: string,
    options?: {
      byteSwap?: boolean;
      sourceType?: "module" | "script";
      encodedFileName?: string;
      /**
       * Strip diagnostic information from compiled function bytecode.
       *
       * - `false` (or omitted): keep everything — full source text,
       *   filename, line numbers, and pc-to-line mapping.
       * - `"source"`: drop the source-text storage from compiled
       *   function bytecode. Stack frames still know their filename
       *   and line numbers, but `Function.prototype.toString` on
       *   those functions returns a synthetic `[native code]`-style
       *   body instead of the original source.
       * - `"debug"`: drop ALL debug info — filename, line numbers,
       *   pc-to-line mapping, and source text. Subsumes `"source"`.
       *   Stack traces lose file/line attribution. Use only for
       *   size-sensitive deployments where diagnostic frames don't
       *   matter.
       */
      strip?: "source" | "debug" | false;
    }
  ): ArrayBuffer;

  /**
   * Convert the provided value into bytecode. Doesn't work with all values.
   *
   * By default, cycles and shared references are preserved — if the same
   * inner object appears at two positions in `value`, the result
   * deserialized via `toValue` will have those positions referencing a
   * single object. Self-referential graphs (e.g. `obj.self = obj`) round-
   * trip correctly. To opt out and produce a stream that errors on
   * cycles, pass `preserveReferences: false`.
   *
   * To serialize Error instances (including `TypeError`, `RangeError`,
   * `SyntaxError`, `ReferenceError`, `URIError`, `EvalError`,
   * `AggregateError`, `SuppressedError`, and `InternalError`), pass
   * `serializeErrors: true`.
   * Without it, attempting to serialize any Error instance throws.
   */
  export function fromValue(
    value: any,
    options?: {
      byteSwap?: boolean;
      /**
       * Preserve shared references and cycles in the serialized output.
       * When true (the default), object graphs with cycles or shared
       * inner objects are encoded with back-references so they round-
       * trip via `toValue` with identity preserved. When false, the
       * serializer throws on encountering a cycle. The matching
       * `preserveReferences` option on `toValue` must be set to decode
       * a stream produced with this flag on.
       */
      preserveReferences?: boolean;
      /**
       * Permit `Error` instances (and the native Error subclasses) to be
       * serialized. Defaults to `false` for backward compatibility. When
       * deserializing the resulting bytecode via `toValue`, pass the
       * matching option so the Error is reified to a real instance.
       */
      serializeErrors?: boolean;
    }
  ): ArrayBuffer;

  /**
   * Convert the provided bytecode into a value.
   *
   * Pass `preserveReferences: false` (the default is true) to reject
   * streams that contain back-references — attempting to decode such a
   * stream throws "invalid tag". Streams produced by `fromValue` with
   * its default settings (or with `preserveReferences: true` explicitly)
   * require the reader's `preserveReferences` to be true as well.
   *
   * Pass `serializeErrors: true` to reify any serialized Error frames
   * (see `fromValue`) back into real Error instances. Attempting to
   * deserialize a bytecode stream that contains an Error frame without
   * this option throws "invalid tag".
   */
  export function toValue(
    bytecode: ArrayBuffer,
    options?: {
      preserveReferences?: boolean;
      serializeErrors?: boolean;
    }
  ): any;
}

declare module "quickjs:context" {
  /**
   * A separate global context (or 'realm') within which code can be executed.
   */
  export class Context {
    /**
     * Create a new global context (or 'realm') within code can be executed.
     *
     * @param options Options for what globals/modules/etc to make available within the context.
     *
     * The following globals are always present, regardless of options:
     *
     * - Object
     * - Function
     * - Error
     * - EvalError
     * - RangeError
     * - ReferenceError
     * - SyntaxError
     * - TypeError
     * - URIError
     * - InternalError
     * - AggregateError
     * - SuppressedError
     * - DisposableStack
     * - Array
     * - parseInt
     * - parseFloat
     * - isNaN
     * - isFinite
     * - decodeURI
     * - decodeURIComponent
     * - encodeURI
     * - encodeURIComponent
     * - escape
     * - unescape
     * - Infinity
     * - NaN
     * - undefined
     * - Number
     * - Boolean
     * - String
     * - Math
     * - Reflect
     * - Symbol
     * - eval (but it doesn't work unless the `eval` option is enabled)
     * - globalThis
     *
     * Note that new contexts don't have a `scriptArgs` global. If you need one
     * to be present in the new context, you can add one onto the Context's
     * `globalThis` property.
     */
    constructor(options?: {
      /** Enables `Date`. Defaults to `true` */
      date?: boolean;

      /** Enables `eval`. Defaults to `true` */
      eval?: boolean;

      /** Enables `String.prototype.normalize`. Defaults to `true`. */
      stringNormalize?: boolean;

      /** Enables `RegExp`. Defaults to `true`. */
      regExp?: boolean;

      /** Enables `JSON`. Defaults to `true`. */
      json?: boolean;

      /** Enables `Proxy`. Defaults to `true`. */
      proxy?: boolean;

      /** Enables `Map` and `Set`. Defaults to `true`. */
      mapSet?: boolean;

      /**
       * Enables:
       *
       * - ArrayBuffer
       * - SharedArrayBuffer
       * - Uint8ClampedArray
       * - Int8Array
       * - Uint8Array
       * - Int16Array
       * - Uint16Array
       * - Int32Array
       * - Uint32Array
       * - BigInt64Array
       * - BigUint64Array
       * - Float32Array
       * - Float64Array
       * - DataView
       *
       * Defaults to `true`.
       */
      typedArrays?: boolean;

      /**
       * Enables:
       *
       * - Promise
       * - async functions
       * - async iterators
       * - async generators
       * - AsyncDisposableStack
       *
       * Defaults to `true`.
       */
      promise?: boolean;

      /**
       * Enables `Temporal`. Defaults to `true`.
       *
       * Has no effect if QuickJS was built with `CONFIG_TEMPORAL_INTL=0`, in
       * which case `Temporal` is never available.
       */
      temporal?: boolean;

      /**
       * Enables `Intl`, and makes `toLocaleString` and related methods (such as
       * `Number.prototype.toLocaleString`, `Date.prototype.toLocaleString`, and
       * `String.prototype.localeCompare`) use it. Defaults to `true`.
       *
       * Has no effect if QuickJS was built with `CONFIG_TEMPORAL_INTL=0`, in
       * which case `Intl` is never available.
       */
      intl?: boolean;

      /** Enables `inspect`. Defaults to `true`. */
      inspect?: boolean;
      /** Enables `console`. Defaults to `true`. */
      console?: boolean;
      /** Enables `print`. Defaults to `true`. */
      print?: boolean;
      /** Enables `require`. Defaults to `true`. */
      moduleGlobals?: boolean;
      /**
       * Enables `setTimeout`, `clearTimeout`, `setInterval`, and
       * `clearInterval`. Defaults to `true`.
       */
      timers?: boolean;

      /** Enable builtin modules. */
      modules?: {
        /** Enables the "quickjs:bytecode" module. Defaults to `true`. */
        "quickjs:bytecode"?: boolean;
        /** Enables the "quickjs:cmdline" module. Defaults to `true`. */
        "quickjs:cmdline"?: boolean;
        /** Enables the "quickjs:context" module. Defaults to `true`. */
        "quickjs:context"?: boolean;
        /** Enables the "quickjs:curl" module. Defaults to `true`. */
        "quickjs:curl"?: boolean;
        /** Enables the "quickjs:encoding" module. Defaults to `true`. */
        "quickjs:encoding"?: boolean;
        /** Enables the "quickjs:engine" module. Defaults to `true`. */
        "quickjs:engine"?: boolean;
        /** Enables the "quickjs:os" module. Defaults to `true`. */
        "quickjs:os"?: boolean;
        /** Enables the "quickjs:std" module. Defaults to `true`. */
        "quickjs:std"?: boolean;
        /** Enables the "quickjs:timers" module. Defaults to `true`. */
        "quickjs:timers"?: boolean;
      };
    });

    /**
     * The `globalThis` object used by this context.
     *
     * You can add to or remove from it to change what is visible to the context.
     */
    globalThis: typeof globalThis;

    /**
     * Runs code within the context and returns the result.
     *
     * @param code The code to run.
     */
    eval(code: string): any;
  }
}

declare module "quickjs:encoding" {
  export function toUtf8(input: ArrayBuffer): string;
  export function fromUtf8(input: string): ArrayBuffer;

  /**
   * Encodes a string into bytes, following the WHATWG Encoding standard.
   * Supports UTF-8, UTF-16LE, UTF-16BE, Shift_JIS, Windows-1252, Windows-1251,
   * Big5, EUC-KR, EUC-JP, and GB18030 encodings.
   */
  export class TextEncoder {
    constructor(label?: TextEncodingLabel);
    readonly encoding: TextEncoding;
    /**
     * Encodes the input string into bytes.
     * @param input The string to encode.
     * @param options Options for encoding. The `stream` option (non-standard) can be used
     *                to preserve state for stateful encodings like UTF-16.
     */
    encode(input?: string, options?: { stream?: boolean }): Uint8Array;
    /**
     * Encodes the source string into the destination Uint8Array.
     * Note: Unlike the standard TextEncoder, this supports all encodings (non-standard extension).
     */
    encodeInto(
      source: string,
      destination: Uint8Array
    ): { read: number; written: number };
  }

  /** The canonical encoding name returned by `.encoding` property */
  type TextEncoding =
    | "utf-8"
    | "utf-16le"
    | "utf-16be"
    | "shift_jis"
    | "windows-1252"
    | "windows-1251"
    | "big5"
    | "euc-kr"
    | "euc-jp"
    | "gb18030";

  /** All encoding labels accepted by TextEncoder/TextDecoder constructor */
  type TextEncodingLabel =
    | TextEncoding
    // UTF-8 aliases
    | "utf8"
    | "unicode-1-1-utf-8"
    // UTF-16 aliases
    | "utf-16"
    // Shift_JIS aliases
    | "shift-jis"
    | "sjis"
    | "csshiftjis"
    | "ms932"
    | "ms_kanji"
    | "windows-31j"
    | "x-sjis"
    // Windows-1252 aliases (WHATWG maps iso-8859-1 to windows-1252)
    | "cp1252"
    | "iso-8859-1"
    | "iso8859-1"
    | "iso_8859-1"
    | "latin1"
    | "iso-8859-15"
    | "us-ascii"
    | "ascii"
    | "x-cp1252"
    // Windows-1251 aliases
    | "cp1251"
    | "x-cp1251"
    // Big5 aliases
    | "big5-hkscs"
    | "cn-big5"
    | "csbig5"
    | "x-x-big5"
    // EUC-KR aliases
    | "cseuckr"
    | "korean"
    | "ks_c_5601-1987"
    | "iso-ir-149"
    | "csksc"
    // EUC-JP aliases
    | "cseucpkdfmtjapanese"
    | "x-euc-jp"
    // GB18030 aliases (WHATWG maps gb2312 and gbk to gb18030)
    | "gb2312"
    | "gbk"
    | "chinese"
    | "csgb2312"
    | "x-gbk"
    | "gb_2312-80"
    | "iso-ir-58";

  /**
   * Decodes bytes into a string, following the WHATWG Encoding standard.
   * Supports UTF-8, UTF-16LE, UTF-16BE, Shift_JIS, Windows-1252, Windows-1251,
   * Big5, EUC-KR, EUC-JP, and GB18030 encodings.
   */
  export class TextDecoder {
    constructor(
      label?: TextEncodingLabel,
      options?: { fatal?: boolean; ignoreBOM?: boolean }
    );
    readonly encoding: TextEncoding;
    readonly fatal: boolean;
    readonly ignoreBOM: boolean;
    decode(
      input?: ArrayBuffer | ArrayBufferView,
      options?: { stream?: boolean }
    ): string;
  }
}


declare const std: typeof import("quickjs:std");
declare const os: typeof import("quickjs:os");