@napi-rs/cli 3.9.0 → 3.10.0

package/dist/index.d.ts

@@ -304,7 +304,7 @@ interface Target {
  *   - `sys` = The system name, for example `linux`, `windows`, `darwin`, etc. none is typically used for bare-metal without an OS.
  *   - `abi` = The ABI, for example `gnu`, `android`, `eabi`, etc.
  */
-declare function parseTriple(rawTriple: string): Target;
+export declare function parseTriple(rawTriple: string): Target;
 //#endregion
 //#region src/utils/config.d.ts
 type ValueOfConstArray<T> = T[Exclude<keyof T, keyof Array<any>>];
@@ -378,6 +378,27 @@ interface UserNapiConfig {
      * @default 4000 pages (250 MiB), or 1024 pages (64 MiB) for the deferred workerd loader
      */
     initialMemory?: number;
+    /**
+     * Initial linear memory, in 64 KiB pages, for the **threadless**
+     * (`wasm32-wasip1`) loaders only: the Node CJS loader, the browser loader
+     * and the deferred `./workerd` loader.
+     *
+     * The threaded loaders allocate one `shared: true` memory that every
+     * wasi-threads worker maps, so every worker stack and every thread's
+     * allocations come out of it and growing it is a cross-thread event; it is
+     * sized for the whole pool up front. The threadless loaders drive a single
+     * thread through a plain growable `ArrayBuffer`: they only have to clear
+     * the module's own link-time floor (`-zstack-size` plus static data) and
+     * grow on demand, which is what lets the same build fit a host with a hard
+     * isolate cap such as workerd's 128 MiB.
+     *
+     * Falls back to `initialMemory` when unset, so existing projects are
+     * unaffected.
+     *
+     * @default `initialMemory` (4000 pages), or 1024 pages for the deferred
+     *   `./workerd` loader
+     */
+    threadlessInitialMemory?: number;
     /**
      * @default 65536 pages (4GiB)
      */
@@ -400,6 +421,34 @@ interface UserNapiConfig {
      * @default true when every configured target is WASI, false otherwise
      */
     optionalDependency?: boolean;
+    /**
+     * Whether the generated WASI loaders bootstrap the `napi-async-runtime`
+     * CurrentThread JavaScript hosts.
+     *
+     * A binding built with the `napi-async-runtime` crate runs the
+     * `CurrentThread` flavor on every WebAssembly target (it is the only
+     * flavor there). Its futures make no progress until a task host is
+     * registered, and its timers never fire until a timer host is, so the
+     * loader must install both right after instantiation and unregister them
+     * before the environment is destroyed.
+     *
+     * Enabling this emits that bootstrap in the node, browser and deferred
+     * (workerd) loaders, and declares `@napi-rs/async-runtime` in the
+     * generated `<packageName>-wasm32-*` packages. The loader delegates the
+     * whole host contract — the seven exports, contract version 4, the
+     * reservation identity, the liveness probe and the rollback — to that
+     * package, so a binding that does not actually expose the contract fails
+     * loudly at load with `ERR_NAPI_ASYNC_RUNTIME_BINDING_MISMATCH`.
+     *
+     * The bootstrap runs after instantiation, so after `#[module_init]`: the
+     * host registration functions are exports of the binding itself. Code that
+     * runs during module registration must not create timers (`sleep_until`
+     * fails loud at creation without a timer host) and cannot expect task
+     * progress until the loader has returned.
+     *
+     * @default false
+     */
+    asyncRuntime?: boolean;
     /**
      * Browser wasm binding configuration
      */
@@ -482,7 +531,7 @@ type NapiConfig = Required<Pick<UserNapiConfig, 'binaryName' | 'packageName' | '
   targets: Target[];
   packageJson: CommonPackageJsonFields;
 };
-declare function readNapiConfig(path: string, configPath?: string): Promise<NapiConfig>;
+export declare function readNapiConfig(path: string, configPath?: string): Promise<NapiConfig>;
 //#endregion
 //#region src/api/build.d.ts
 type OutputKind = 'js' | 'dts' | 'node' | 'exe' | 'wasm';
@@ -520,7 +569,7 @@ interface WriteJsBindingOptions {
   wasiFlavors?: string[];
 }
 /** Write a platform binding loader in the requested module format. */
-declare function writeJsBinding(options: WriteJsBindingOptions): Promise<Output | undefined>;
+export declare function writeJsBinding(options: WriteJsBindingOptions): Promise<Output | undefined>;
 interface GenerateTypeDefOptions {
   typeDefDir: string;
   noDtsHeader?: boolean;
@@ -531,6 +580,18 @@ interface GenerateTypeDefOptions {
   constEnum?: boolean;
   runtimeStringEnum?: boolean;
   cwd: string;
+  /**
+   * Declare the generated loader's `__napiBindingTarget` export. Set it for
+   * builds that emit a loader; a build that emits none declares nothing. The
+   * declared union covers every artifact a loader can hand back, not only the
+   * targets this package builds — see {@link BINDING_TARGET_TYPE_UNION}.
+   *
+   * Whether the root loader is written depends on the exports this build
+   * produced, which only typegen knows, so a predicate may be passed instead
+   * of a flag; it is called with the generated export list. See
+   * {@link bindingTargetDeclarationPredicate}.
+   */
+  declareBindingTarget?: boolean | ((exports: readonly string[]) => boolean);
 }
 /**
  * Walk the napi-derive intermediate type-def directory, render every entry
@@ -538,10 +599,16 @@ interface GenerateTypeDefOptions {
  * `.d.ts` source plus the list of identifiers to re-export from
  * `index.js`.
  */
-declare function generateTypeDef(options: GenerateTypeDefOptions): Promise<{
+export declare function generateTypeDef(options: GenerateTypeDefOptions): Promise<{
   exports: string[];
   dts: string;
   dtsWithTypeImports: string;
+  /**
+   * The `.d.ts` header as rendered, before anything the generated body needs
+   * was appended to it. `ensureBindingTargetDeclaration` takes it to tell a
+   * declaration the header owns from one this build wrote.
+   */
+  header: string;
 }>;
 //#endregion
 //#region src/def/create-npm-dirs.d.ts
@@ -1031,7 +1098,7 @@ declare class VersionCommand extends BaseVersionCommand {
 }
 //#endregion
 //#region src/index.d.ts
-declare const cli: Cli<import("clipanion").BaseContext>;
+export declare const cli: Cli<import("clipanion").BaseContext>;
 /**
  *
  * @usage
@@ -1044,7 +1111,7 @@ declare const cli: Cli<import("clipanion").BaseContext>;
  * })
  * ```
  */
-declare class NapiCli {
+export declare class NapiCli {
   artifacts: typeof collectArtifacts;
   new: typeof newProject;
   build: typeof buildProject;
@@ -1054,14 +1121,14 @@ declare class NapiCli {
   universalize: typeof universalizeBinaries;
   version: typeof version$1;
 }
-declare function createBuildCommand(args: string[]): BuildCommand;
-declare function createArtifactsCommand(args: string[]): ArtifactsCommand;
-declare function createCreateNpmDirsCommand(args: string[]): CreateNpmDirsCommand;
-declare function createPrePublishCommand(args: string[]): PrePublishCommand;
-declare function createRenameCommand(args: string[]): RenameCommand;
-declare function createUniversalizeCommand(args: string[]): UniversalizeCommand;
-declare function createVersionCommand(args: string[]): VersionCommand;
-declare function createNewCommand(args: string[]): NewCommand;
+export declare function createBuildCommand(args: string[]): BuildCommand;
+export declare function createArtifactsCommand(args: string[]): ArtifactsCommand;
+export declare function createCreateNpmDirsCommand(args: string[]): CreateNpmDirsCommand;
+export declare function createPrePublishCommand(args: string[]): PrePublishCommand;
+export declare function createRenameCommand(args: string[]): RenameCommand;
+export declare function createUniversalizeCommand(args: string[]): UniversalizeCommand;
+export declare function createVersionCommand(args: string[]): VersionCommand;
+export declare function createNewCommand(args: string[]): NewCommand;
 //#endregion
-export { type GenerateTypeDefOptions, NapiCli, type WriteJsBindingOptions, cli, createArtifactsCommand, createBuildCommand, createCreateNpmDirsCommand, createNewCommand, createPrePublishCommand, createRenameCommand, createUniversalizeCommand, createVersionCommand, generateTypeDef, parseTriple, readNapiConfig, writeJsBinding };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.d.ts","names":["BuildOptions","RawBuildOptions","RawNewOptions","version","version"],"sources":["../src/def/artifacts.d.ts","../src/api/artifacts.d.ts","../src/def/build.d.ts","../src/utils/log.d.ts","../src/utils/target.d.ts","../src/utils/config.d.ts","../src/api/build.d.ts","../src/def/create-npm-dirs.d.ts","../src/api/create-npm-dirs.d.ts","../src/def/new.d.ts","../src/api/new.d.ts","../src/def/pre-publish.d.ts","../src/api/pre-publish.d.ts","../src/def/rename.d.ts","../src/api/rename.d.ts","../src/def/universalize.d.ts","../src/api/universalize.d.ts","../src/def/version.d.ts","../src/api/version.d.ts","../src/commands/artifacts.d.ts","../src/commands/build.d.ts","../src/commands/create-npm-dirs.d.ts","../src/commands/new.d.ts","../src/commands/pre-publish.d.ts","../src/commands/rename.d.ts","../src/commands/universalize.d.ts","../src/commands/version.d.ts","../src/index.d.ts"],"sourcesContent":["import { Command } from 'clipanion';\nexport declare abstract class BaseArtifactsCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    outputDir: string;\n    npmDir: string;\n    buildOutputDir?: string;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        outputDir: string;\n        npmDir: string;\n        buildOutputDir: string | undefined;\n    };\n}\n/**\n * Copy artifacts from Github Actions into npm packages and ready to publish\n */\nexport interface ArtifactsOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where all built `.node` files put, same as `--output-dir` of build command\n     *\n     * @default './artifacts'\n     */\n    outputDir?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n    /**\n     * Path to the build output dir, only needed when targets contain a WASI target\n     */\n    buildOutputDir?: string;\n}\nexport declare function applyDefaultArtifactsOptions(options: ArtifactsOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    outputDir: string;\n    npmDir: string;\n    /**\n     * Path to the build output dir, only needed when targets contain a WASI target\n     */\n    buildOutputDir?: string;\n};\n","import { type ArtifactsOptions } from '../def/artifacts.js';\nexport declare function collectArtifacts(userOptions: ArtifactsOptions): Promise<void>;\n","import { Command } from 'clipanion';\nexport declare abstract class BaseBuildCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    target?: string;\n    cwd?: string;\n    manifestPath?: string;\n    configPath?: string;\n    packageJsonPath?: string;\n    targetDir?: string;\n    outputDir?: string;\n    platform?: boolean;\n    jsPackageName?: string;\n    constEnum?: boolean;\n    runtimeStringEnum?: boolean;\n    jsBinding?: string;\n    noJsBinding?: boolean;\n    dts?: string;\n    dtsHeader?: string;\n    noDtsHeader?: boolean;\n    dtsCache: boolean;\n    format?: 'esm' | 'commonjs';\n    esm?: boolean;\n    commonjs?: boolean;\n    strip?: boolean;\n    release?: boolean;\n    verbose?: boolean;\n    bin?: string;\n    package?: string;\n    profile?: string;\n    crossCompile?: boolean;\n    useCross?: boolean;\n    useNapiCross?: boolean;\n    watch?: boolean;\n    features?: string[];\n    allFeatures?: boolean;\n    noDefaultFeatures?: boolean;\n    /**\n     * Return the parsed build options.\n     */\n    getOptions(): {\n        target: string | undefined;\n        cwd: string | undefined;\n        manifestPath: string | undefined;\n        configPath: string | undefined;\n        packageJsonPath: string | undefined;\n        targetDir: string | undefined;\n        outputDir: string | undefined;\n        platform: boolean | undefined;\n        jsPackageName: string | undefined;\n        constEnum: boolean | undefined;\n        runtimeStringEnum: boolean | undefined;\n        jsBinding: string | undefined;\n        noJsBinding: boolean | undefined;\n        dts: string | undefined;\n        dtsHeader: string | undefined;\n        noDtsHeader: boolean | undefined;\n        dtsCache: boolean;\n        format: \"esm\" | \"commonjs\" | undefined;\n        esm: boolean | undefined;\n        commonjs: boolean | undefined;\n        strip: boolean | undefined;\n        release: boolean | undefined;\n        verbose: boolean | undefined;\n        bin: string | undefined;\n        package: string | undefined;\n        profile: string | undefined;\n        crossCompile: boolean | undefined;\n        useCross: boolean | undefined;\n        useNapiCross: boolean | undefined;\n        watch: boolean | undefined;\n        features: string[] | undefined;\n        allFeatures: boolean | undefined;\n        noDefaultFeatures: boolean | undefined;\n    };\n}\n/**\n * Build the NAPI-RS project\n */\nexport interface BuildOptions {\n    /**\n     * Build for the target triple, bypassed to `cargo build --target`\n     */\n    target?: string;\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     */\n    cwd?: string;\n    /**\n     * Path to `Cargo.toml`\n     */\n    manifestPath?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     */\n    packageJsonPath?: string;\n    /**\n     * Directory for all crate generated artifacts, see `cargo build --target-dir`\n     */\n    targetDir?: string;\n    /**\n     * Path to where all the built files would be put. Default to the crate folder\n     */\n    outputDir?: string;\n    /**\n     * Add platform triple to the generated nodejs binding file, eg: `[name].linux-x64-gnu.node`\n     */\n    platform?: boolean;\n    /**\n     * Package name in generated js binding file. Only works with `--platform` flag\n     */\n    jsPackageName?: string;\n    /**\n     * Whether generate const enum for typescript bindings\n     */\n    constEnum?: boolean;\n    /**\n     * Emit `#[napi(string_enum)]` enums as runtime enums (`export declare enum`) under `--no-const-enum`. Default: type-only union.\n     */\n    runtimeStringEnum?: boolean;\n    /**\n     * Path and filename of generated JS binding file. Only works with `--platform` flag. Relative to `--output-dir`.\n     */\n    jsBinding?: string;\n    /**\n     * Whether to disable the generation JS binding file. Only works with `--platform` flag.\n     */\n    noJsBinding?: boolean;\n    /**\n     * Path and filename of generated type def file. Relative to `--output-dir`\n     */\n    dts?: string;\n    /**\n     * Custom file header for generated type def file. Only works when `typedef` feature enabled.\n     */\n    dtsHeader?: string;\n    /**\n     * Whether to disable the default file header for generated type def file. Only works when `typedef` feature enabled.\n     */\n    noDtsHeader?: boolean;\n    /**\n     * Whether to enable the dts cache, default to true\n     *\n     * @default true\n     */\n    dtsCache?: boolean;\n    /**\n     * The module format of the generated JS binding file. Only works with `--platform` flag. Defaults to `commonjs`.\n     */\n    format?: 'esm' | 'commonjs';\n    /**\n     * Alias for `--format esm`.\n     */\n    esm?: boolean;\n    /**\n     * Alias for `--format commonjs`.\n     */\n    commonjs?: boolean;\n    /**\n     * Whether strip the library to achieve the minimum file size\n     */\n    strip?: boolean;\n    /**\n     * Build in release mode\n     */\n    release?: boolean;\n    /**\n     * Verbosely log build command trace\n     */\n    verbose?: boolean;\n    /**\n     * Build only the specified binary\n     */\n    bin?: string;\n    /**\n     * Build the specified library or the one at cwd\n     */\n    package?: string;\n    /**\n     * Build artifacts with the specified profile\n     */\n    profile?: string;\n    /**\n     * [experimental] cross compile by replacing the cargo subcommand: Windows MSVC targets from a non-Windows host build with `cargo-xwin` (`windows-gnu` targets are rejected, `cargo-xwin` cannot handle them), non-Windows targets build with `cargo-zigbuild` (requires `zig` on PATH). The selected subcommand is auto-installed on first use. Cannot be combined with `--use-cross`, `--use-napi-cross` or `--watch`\n     */\n    crossCompile?: boolean;\n    /**\n     * [experimental] not recommended, prefer `--cross-compile` or `--use-napi-cross`: build in a Docker or Podman container with [cross](https://github.com/cross-rs/cross), which must be installed manually and needs a running container engine. Cannot be combined with `--cross-compile`, `--use-napi-cross` or `--watch`\n     */\n    useCross?: boolean;\n    /**\n     * [experimental] download a prebuilt gcc cross toolchain from `@napi-rs/cross-toolchain` (glibc 2.17) and set linker and C compiler environment variables. Linux glibc targets only (x64, arm64, armv7, ppc64le, s390x) on a Linux x64 or arm64 host, any other target or host errors. Cannot be combined with `--cross-compile` or `--use-cross`\n     */\n    useNapiCross?: boolean;\n    /**\n     * watch the crate changes and build continuously with `cargo-watch` crates\n     */\n    watch?: boolean;\n    /**\n     * Space-separated list of features to activate\n     */\n    features?: string[];\n    /**\n     * Activate all available features\n     */\n    allFeatures?: boolean;\n    /**\n     * Do not activate the `default` feature\n     */\n    noDefaultFeatures?: boolean;\n}\nexport declare function applyDefaultBuildOptions(options: BuildOptions): {\n    /**\n     * Build for the target triple, bypassed to `cargo build --target`\n     */\n    target?: string;\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     */\n    cwd?: string;\n    /**\n     * Path to `Cargo.toml`\n     */\n    manifestPath?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     */\n    packageJsonPath?: string;\n    /**\n     * Directory for all crate generated artifacts, see `cargo build --target-dir`\n     */\n    targetDir?: string;\n    /**\n     * Path to where all the built files would be put. Default to the crate folder\n     */\n    outputDir?: string;\n    /**\n     * Add platform triple to the generated nodejs binding file, eg: `[name].linux-x64-gnu.node`\n     */\n    platform?: boolean;\n    /**\n     * Package name in generated js binding file. Only works with `--platform` flag\n     */\n    jsPackageName?: string;\n    /**\n     * Whether generate const enum for typescript bindings\n     */\n    constEnum?: boolean;\n    /**\n     * Emit `#[napi(string_enum)]` enums as runtime enums (`export declare enum`) under `--no-const-enum`. Default: type-only union.\n     */\n    runtimeStringEnum?: boolean;\n    /**\n     * Path and filename of generated JS binding file. Only works with `--platform` flag. Relative to `--output-dir`.\n     */\n    jsBinding?: string;\n    /**\n     * Whether to disable the generation JS binding file. Only works with `--platform` flag.\n     */\n    noJsBinding?: boolean;\n    /**\n     * Path and filename of generated type def file. Relative to `--output-dir`\n     */\n    dts?: string;\n    /**\n     * Custom file header for generated type def file. Only works when `typedef` feature enabled.\n     */\n    dtsHeader?: string;\n    /**\n     * Whether to disable the default file header for generated type def file. Only works when `typedef` feature enabled.\n     */\n    noDtsHeader?: boolean;\n    dtsCache: boolean;\n    /**\n     * The module format of the generated JS binding file. Only works with `--platform` flag. Defaults to `commonjs`.\n     */\n    format?: \"esm\" | \"commonjs\";\n    /**\n     * Alias for `--format esm`.\n     */\n    esm?: boolean;\n    /**\n     * Alias for `--format commonjs`.\n     */\n    commonjs?: boolean;\n    /**\n     * Whether strip the library to achieve the minimum file size\n     */\n    strip?: boolean;\n    /**\n     * Build in release mode\n     */\n    release?: boolean;\n    /**\n     * Verbosely log build command trace\n     */\n    verbose?: boolean;\n    /**\n     * Build only the specified binary\n     */\n    bin?: string;\n    /**\n     * Build the specified library or the one at cwd\n     */\n    package?: string;\n    /**\n     * Build artifacts with the specified profile\n     */\n    profile?: string;\n    /**\n     * [experimental] cross compile by replacing the cargo subcommand: Windows MSVC targets from a non-Windows host build with `cargo-xwin` (`windows-gnu` targets are rejected, `cargo-xwin` cannot handle them), non-Windows targets build with `cargo-zigbuild` (requires `zig` on PATH). The selected subcommand is auto-installed on first use. Cannot be combined with `--use-cross`, `--use-napi-cross` or `--watch`\n     */\n    crossCompile?: boolean;\n    /**\n     * [experimental] not recommended, prefer `--cross-compile` or `--use-napi-cross`: build in a Docker or Podman container with [cross](https://github.com/cross-rs/cross), which must be installed manually and needs a running container engine. Cannot be combined with `--cross-compile`, `--use-napi-cross` or `--watch`\n     */\n    useCross?: boolean;\n    /**\n     * [experimental] download a prebuilt gcc cross toolchain from `@napi-rs/cross-toolchain` (glibc 2.17) and set linker and C compiler environment variables. Linux glibc targets only (x64, arm64, armv7, ppc64le, s390x) on a Linux x64 or arm64 host, any other target or host errors. Cannot be combined with `--cross-compile` or `--use-cross`\n     */\n    useNapiCross?: boolean;\n    /**\n     * watch the crate changes and build continuously with `cargo-watch` crates\n     */\n    watch?: boolean;\n    /**\n     * Space-separated list of features to activate\n     */\n    features?: string[];\n    /**\n     * Activate all available features\n     */\n    allFeatures?: boolean;\n    /**\n     * Do not activate the `default` feature\n     */\n    noDefaultFeatures?: boolean;\n};\n","declare module 'obug' {\n    interface Debugger {\n        info: typeof console.error;\n        warn: typeof console.error;\n        error: typeof console.error;\n    }\n}\nexport declare const debugFactory: (namespace: string) => import(\"obug\").Debugger;\nexport declare const debug: import(\"obug\").Debugger;\n","export type Platform = NodeJS.Platform | 'wasm' | 'wasi' | 'openharmony';\nexport declare const UNIVERSAL_TARGETS: {\n    readonly 'universal-apple-darwin': readonly [\"aarch64-apple-darwin\", \"x86_64-apple-darwin\"];\n};\nexport declare const AVAILABLE_TARGETS: readonly [\"aarch64-apple-darwin\", \"aarch64-linux-android\", \"aarch64-unknown-linux-gnu\", \"aarch64-unknown-linux-musl\", \"aarch64-unknown-linux-ohos\", \"aarch64-pc-windows-msvc\", \"x86_64-apple-darwin\", \"x86_64-pc-windows-msvc\", \"x86_64-pc-windows-gnu\", \"x86_64-unknown-linux-gnu\", \"x86_64-unknown-linux-musl\", \"x86_64-unknown-linux-ohos\", \"x86_64-unknown-freebsd\", \"i686-pc-windows-msvc\", \"armv7-unknown-linux-gnueabihf\", \"armv7-unknown-linux-musleabihf\", \"armv7-linux-androideabi\", \"universal-apple-darwin\", \"loongarch64-unknown-linux-gnu\", \"riscv64gc-unknown-linux-gnu\", \"powerpc64le-unknown-linux-gnu\", \"s390x-unknown-linux-gnu\", \"wasm32-wasip1\", \"wasm32-wasip1-threads\"];\nexport type TargetTriple = (typeof AVAILABLE_TARGETS)[number];\nexport declare const DEFAULT_TARGETS: readonly [\"x86_64-apple-darwin\", \"aarch64-apple-darwin\", \"x86_64-pc-windows-msvc\", \"x86_64-unknown-linux-gnu\"];\nexport declare const TARGET_LINKER: Record<string, string>;\ntype NodeJSArch = 'arm' | 'arm64' | 'ia32' | 'loong64' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 'riscv64' | 's390' | 's390x' | 'x32' | 'x64' | 'universal' | 'wasm32';\nexport declare const NodeArchToCpu: Record<string, string>;\nexport declare const UniArchsByPlatform: Partial<Record<Platform, NodeJSArch[]>>;\nexport interface Target {\n    triple: string;\n    platformArchABI: string;\n    platform: Platform;\n    arch: NodeJSArch;\n    abi: string | null;\n}\nexport type WasiFlavor = 'single' | 'threads';\nexport interface WasiTarget {\n    canonicalTriple: string;\n    flavor: WasiFlavor;\n    platformArchABI: string;\n}\n/**\n * Resolve historical WASI spellings to one build target and one artifact\n * identity. `wasm32-wasi` historically produced the threaded package, so it\n * must never be inferred as threadless merely because its name lacks the\n * `-threads` suffix.\n */\nexport declare function getWasiTarget(target: string | Pick<Target, 'triple'>): WasiTarget | undefined;\nexport declare function wasiTargetHasThreads(target: string | Pick<Target, 'triple'>): boolean;\n/**\n * A triple is a specific format for specifying a target architecture.\n * Triples may be referred to as a target triple which is the architecture for the artifact produced, and the host triple which is the architecture that the compiler is running on.\n * The general format of the triple is `<arch><sub>-<vendor>-<sys>-<abi>` where:\n *   - `arch` = The base CPU architecture, for example `x86_64`, `i686`, `arm`, `thumb`, `mips`, etc.\n *   - `sub` = The CPU sub-architecture, for example `arm` has `v7`, `v7s`, `v5te`, etc.\n *   - `vendor` = The vendor, for example `unknown`, `apple`, `pc`, `nvidia`, etc.\n *   - `sys` = The system name, for example `linux`, `windows`, `darwin`, etc. none is typically used for bare-metal without an OS.\n *   - `abi` = The ABI, for example `gnu`, `android`, `eabi`, etc.\n */\nexport declare function parseTriple(rawTriple: string): Target;\nexport declare function getSystemDefaultTarget(): Target;\nexport declare function getTargetLinker(target: string): string | undefined;\n/**\n * Loader-file suffix for a WASI flavor, derived from its `platformArchABI`:\n * the legacy threaded flavor keeps the historical `wasi` stem\n * (`<binaryName>.wasi.cjs`, `<binaryName>.wasi-browser.js`), while each\n * distinctly named non-threaded flavor derives its own\n * (`<binaryName>.wasip1.cjs`, `<binaryName>.wasip1-browser.js`, ...).\n */\nexport declare function wasiLoaderSuffix(platformArchABI: string): string;\nexport declare function targetToEnvVar(target: string): string;\nexport {};\n","import { type Target } from './target.js';\nexport type ValueOfConstArray<T> = T[Exclude<keyof T, keyof Array<any>>];\nexport declare const SupportedPackageManagers: readonly [\"yarn\", \"pnpm\"];\nexport declare const SupportedTestFrameworks: readonly [\"ava\"];\nexport type SupportedPackageManager = ValueOfConstArray<typeof SupportedPackageManagers>;\nexport type SupportedTestFramework = ValueOfConstArray<typeof SupportedTestFrameworks>;\n/**\n * Package managers that may publish the **root** package, distinguished by\n * whether they rewrite the manifest while packing it.\n *\n * `yarn` means yarn berry (>= 2); Yarn Classic (1.x) packs the raw manifest\n * like npm does and is spelled `yarn-classic`.\n */\nexport declare const RootPublishers: readonly [\"npm\", \"pnpm\", \"yarn\", \"yarn-classic\"];\nexport type RootPublisher = ValueOfConstArray<typeof RootPublishers>;\nexport interface UserNapiConfig {\n    /**\n     * Name of the binary to be generated, default to `index`\n     */\n    binaryName?: string;\n    /**\n     * Name of the npm package, default to the name of root package.json name\n     *\n     * Always given `@scope/pkg` and arch suffix will be appended like `@scope/pkg-linux-gnu-x64`\n     */\n    packageName?: string;\n    /**\n     * All targets the crate will be compiled for\n     */\n    targets?: string[];\n    /**\n     * The npm client project uses.\n     */\n    npmClient?: string;\n    /**\n     * The package manager that publishes the **root** package.\n     *\n     * `napi pre-publish` publishes only the generated per-platform packages; the\n     * root package is packed and published by the caller, so this cannot be\n     * inferred reliably. pnpm and yarn berry replace `exports` with\n     * `publishConfig.exports` while packing, so under those publishers\n     * `napi pre-publish` validates only the publish-effective export map and the\n     * local `exports` may point at development-only sources. npm and Yarn\n     * Classic ship `exports` untouched.\n     *\n     * Unset — the default — validates both maps, which is correct for every\n     * publisher but rejects development-only conditions such as\n     * `\"dev\": \"./src/index.ts\"`.\n     */\n    rootPublisher?: RootPublisher;\n    /**\n     * Whether generate const enum for typescript bindings\n     */\n    constEnum?: boolean;\n    /**\n     * Emit `#[napi(string_enum)]` enums as runtime enums (`export declare enum`) under `--no-const-enum`. Default: type-only union.\n     */\n    runtimeStringEnum?: boolean;\n    /**\n     * dts header prepend to the generated dts file\n     */\n    dtsHeader?: string;\n    /**\n     * dts header file path to be prepended to the generated dts file\n     * if both dtsHeader and dtsHeaderFile are provided, dtsHeaderFile will be used\n     */\n    dtsHeaderFile?: string;\n    /**\n     * wasm compilation options\n     */\n    wasm?: {\n        /**\n         * https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface/Memory\n         * @default 4000 pages (250 MiB), or 1024 pages (64 MiB) for the deferred workerd loader\n         */\n        initialMemory?: number;\n        /**\n         * @default 65536 pages (4GiB)\n         */\n        maximumMemory?: number;\n        /**\n         * Whether the generated `<packageName>-wasm32-wasi` package is declared as\n         * an `optionalDependency` of the root package.\n         *\n         * When native targets are configured the WASI package is a fallback for\n         * hosts that cannot load a `.node` binary, so declaring it would make every\n         * consumer download the `.wasm` binary they will never load. It is\n         * therefore omitted by default and is expected to be installed on demand by\n         * the environments that need it.\n         *\n         * When WASI is the only configured target it is the primary artifact and is\n         * declared by default.\n         *\n         * Set this explicitly to override either default.\n         *\n         * @default true when every configured target is WASI, false otherwise\n         */\n        optionalDependency?: boolean;\n        /**\n         * Browser wasm binding configuration\n         */\n        browser?: {\n            /**\n             * Whether to use fs module in browser\n             */\n            fs?: boolean;\n            /**\n             * Whether to initialize wasm asynchronously\n             */\n            asyncInit?: boolean;\n            /**\n             * Whether to inject `buffer` to emnapi context\n             */\n            buffer?: boolean;\n            /**\n             * Whether to emit custom events for errors in worker\n             */\n            errorEvent?: boolean;\n        };\n    };\n    /**\n     * @deprecated binaryName instead\n     */\n    name?: string;\n    /**\n     * @deprecated use packageName instead\n     */\n    package?: {\n        name?: string;\n    };\n    /**\n     * @deprecated use targets instead\n     */\n    triples?: {\n        /**\n         * Whether enable default targets\n         */\n        defaults: boolean;\n        /**\n         * Additional targets to be compiled for\n         */\n        additional?: string[];\n    };\n}\nexport interface CommonPackageJsonFields {\n    name: string;\n    version: string;\n    description?: string;\n    keywords?: string[];\n    author?: string;\n    authors?: string[];\n    license?: string;\n    cpu?: string[];\n    os?: string[];\n    libc?: string[];\n    files?: string[];\n    repository?: any;\n    homepage?: any;\n    engines?: Record<string, string>;\n    publishConfig?: any;\n    bugs?: any;\n    napi?: UserNapiConfig;\n    type?: 'module' | 'commonjs';\n    scripts?: Record<string, string>;\n    main?: string;\n    module?: string;\n    types?: string;\n    browser?: string;\n    exports?: any;\n    dependencies?: Record<string, string>;\n    devDependencies?: Record<string, string>;\n    optionalDependencies?: Record<string, string>;\n    ava?: {\n        timeout?: string;\n    };\n}\nexport type NapiConfig = Required<Pick<UserNapiConfig, 'binaryName' | 'packageName' | 'npmClient'>> & Pick<UserNapiConfig, 'wasm' | 'dtsHeader' | 'dtsHeaderFile' | 'constEnum' | 'runtimeStringEnum' | 'rootPublisher'> & {\n    targets: Target[];\n    packageJson: CommonPackageJsonFields;\n};\nexport declare function readNapiConfig(path: string, configPath?: string): Promise<NapiConfig>;\n","import type { BuildOptions as RawBuildOptions } from '../def/build.js';\nimport { type Target, type CargoWorkspaceMetadata } from '../utils/index.js';\ntype OutputKind = 'js' | 'dts' | 'node' | 'exe' | 'wasm';\ntype Output = {\n    kind: OutputKind;\n    path: string;\n};\nexport type BuildFormat = 'esm' | 'commonjs';\ntype BuildOptions = RawBuildOptions & {\n    cargoOptions?: string[];\n};\nexport declare const WASI_ARTIFACT_METADATA_PREFIX = \"// napi-rs-artifact-metadata:\";\ntype CargoConfigFingerprint = readonly [path: string, hash: string];\nexport declare function getCargoDependencyGraphFingerprint(metadata: CargoWorkspaceMetadata, rootPackageId: string): string;\nexport declare function getTypeDefCacheFolder(options: {\n    targetDir: string;\n    crateName: string;\n    manifestPath: string;\n    targetTriple: string;\n    profile: string;\n    features?: string[];\n    allFeatures?: boolean;\n    noDefaultFeatures?: boolean;\n    cargoOptions?: string[];\n    rustFlags?: Record<string, string | undefined>;\n    cargoProfileEnv?: Record<string, string | undefined>;\n    cargoConfig?: CargoConfigFingerprint[];\n    cargoDependencyGraph?: string;\n}): string;\nexport declare function createWasiCompilerFlags(wasiSdkPath: string, wasiTarget: string, hasThreads: boolean, shellEscapedFlags?: boolean): {\n    compileFlags: string;\n    linkerFlags: string;\n};\nexport declare function createArtifactDestinationName(binaryName: string, target: Target, sourceName: string, platform: boolean): string;\nexport declare function selectWasiBrowserTarget(buildTarget: Target, configuredTargets: Target[], emittedTargets: Target[]): Target;\nexport declare function createWasiBrowserEntry(packageName: string, platformArchABI: string, idents: string[]): string;\nexport declare function createWasiDeferredBindingTypeDef(bindingModuleSpecifier: string, hasTypeDef: boolean): string;\nexport declare function prepareWasiBindingTypeDef(source: string, sourcePath: string, destinationPath: string, hasThreads: boolean, packageType?: 'module' | 'commonjs'): string;\nexport declare function collectStaleWasiBuildOutputNames(binaryName: string, buildTarget: Target, configuredTargets: Target[]): Set<string>;\nexport declare function removeWasmCustomSection(binary: Uint8Array, sectionName: string): Uint8Array;\ntype BuildFormatOptions = {\n    format?: string;\n    esm?: boolean;\n    commonjs?: boolean;\n};\n/**\n * Resolve the explicit build format and its legacy CLI/API aliases.\n *\n * CommonJS is the historical default. The aliases are intentionally kept\n * separate from `format` because `--esm` and `--commonjs` are boolean flags,\n * while `--format` takes a value.\n */\nexport declare function resolveBuildFormat(options: BuildFormatOptions): BuildFormat;\n/** Build the configured NAPI-RS crate and generate its output artifacts. */\nexport declare function buildProject(rawOptions: BuildOptions): Promise<{\n    task: Promise<Output[]>;\n    abort: () => void;\n}>;\n/**\n * Validate the combination of the cross-compilation related flags.\n *\n * `--use-cross`, `--use-napi-cross` and `--cross-compile` (`-x`) are three\n * mutually exclusive cross-compilation mechanisms; combining any two of them\n * leaves both active at once and produces broken builds, so it is rejected\n * upfront before any side effect (like auto-installing cargo binaries or\n * downloading toolchains) happens.\n *\n * `--cross-compile` with a `windows-gnu` target is rejected as well: on a\n * non-Windows host it routes the build to `cargo xwin build`, but\n * `cargo-xwin` only sets up MSVC toolchains — for `windows-gnu` targets it\n * silently does nothing and the build dies much later with a cryptic\n * ``error: linker `x86_64-w64-mingw32-gcc` not found`` that never mentions\n * `cargo-xwin`. Only an explicitly requested target (`--target` or\n * `CARGO_BUILD_TARGET`) is inspected, so this validation never has to spawn\n * `rustc -vV`; a non-Windows host's default target can never be\n * `windows-gnu` anyway.\n */\nexport declare function validateCrossCompileFlags(options: {\n    useCross?: boolean;\n    crossCompile?: boolean;\n    useNapiCross?: boolean;\n    watch?: boolean;\n    target?: string;\n}, hostPlatform?: string): void;\n/**\n * Validate that `--use-napi-cross` can actually handle the requested target\n * on the current host. The supported target set is read from the\n * `@napi-rs/cross-toolchain` package, and the pre-built toolchains only run\n * on Linux x64 and Linux arm64 hosts.\n */\nexport declare function validateNapiCrossSupport(targetTriple: string, hostPlatform?: string, hostArch?: string): void;\n/**\n * Compute the environment variables that route a `--use-napi-cross` build\n * through the `@napi-rs/cross-toolchain` toolchain extracted at\n * `toolchainPath`.\n *\n * Follows the same rule as `Builder#setEnvIfNotExists`: a variable the user\n * already set in `env` wins and is not returned, and a present-but-empty\n * variable counts as unset (falsy semantics). The only exceptions are the\n * clang-specific `TARGET_CFLAGS`/`TARGET_CXXFLAGS`, which prepend the sysroot\n * flags to the user's value, and `PATH`, which always gets the toolchain\n * `bin` directory prepended.\n *\n * Exported for tests.\n */\nexport declare function napiCrossToolchainEnvs(toolchainPath: string, targetTriple: string, env?: NodeJS.ProcessEnv): Record<string, string>;\nexport declare function verifyWasiReactor(wasmPath: string): Promise<void>;\nexport interface WriteJsBindingOptions {\n    platform?: boolean;\n    noJsBinding?: boolean;\n    idents: string[];\n    jsBinding?: string;\n    format?: BuildFormat;\n    esm?: boolean;\n    commonjs?: boolean;\n    binaryName: string;\n    packageName: string;\n    version: string;\n    outputDir: string;\n    /**\n     * `platformArchABI`s of the declared WASI targets in fallback preference\n     * order (threaded first). Defaults to the legacy `['wasm32-wasi']` chain\n     * when omitted or empty. Generated loaders expose these exact identities\n     * through `NAPI_RS_WASI_FLAVOR`.\n     */\n    wasiFlavors?: string[];\n}\n/** Write a platform binding loader in the requested module format. */\nexport declare function writeJsBinding(options: WriteJsBindingOptions): Promise<Output | undefined>;\nexport interface GenerateTypeDefOptions {\n    typeDefDir: string;\n    noDtsHeader?: boolean;\n    dtsHeader?: string;\n    dtsHeaderFile?: string;\n    configDtsHeader?: string;\n    configDtsHeaderFile?: string;\n    constEnum?: boolean;\n    runtimeStringEnum?: boolean;\n    cwd: string;\n}\n/**\n * Walk the napi-derive intermediate type-def directory, render every entry\n * into TypeScript via {@link processTypeDef}, and return the concatenated\n * `.d.ts` source plus the list of identifiers to re-export from\n * `index.js`.\n */\nexport declare function generateTypeDef(options: GenerateTypeDefOptions): Promise<{\n    exports: string[];\n    dts: string;\n    dtsWithTypeImports: string;\n}>;\nexport {};\n","import { Command } from 'clipanion';\nexport declare abstract class BaseCreateNpmDirsCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    dryRun: boolean;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        npmDir: string;\n        dryRun: boolean;\n    };\n}\n/**\n * Create npm package dirs for different platforms\n */\nexport interface CreateNpmDirsOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n    /**\n     * Dry run without touching file system\n     *\n     * @default false\n     */\n    dryRun?: boolean;\n}\nexport declare function applyDefaultCreateNpmDirsOptions(options: CreateNpmDirsOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    dryRun: boolean;\n};\n","import { type CreateNpmDirsOptions } from '../def/create-npm-dirs.js';\nexport interface PackageMeta {\n    'dist-tags': {\n        [index: string]: string;\n    };\n}\nexport declare function createNpmDirs(userOptions: CreateNpmDirsOptions): Promise<void>;\n","import { Command } from 'clipanion';\nexport declare abstract class BaseNewCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    $$path: string | undefined;\n    $$name?: string;\n    minNodeApiVersion: number;\n    packageManager: string;\n    license: string;\n    targets: string[];\n    enableDefaultTargets: boolean;\n    enableAllTargets: boolean;\n    enableTypeDef: boolean;\n    enableGithubActions: boolean;\n    testFramework: string;\n    dryRun: boolean;\n    getOptions(): {\n        path: string | undefined;\n        name: string | undefined;\n        minNodeApiVersion: number;\n        packageManager: string;\n        license: string;\n        targets: string[];\n        enableDefaultTargets: boolean;\n        enableAllTargets: boolean;\n        enableTypeDef: boolean;\n        enableGithubActions: boolean;\n        testFramework: string;\n        dryRun: boolean;\n    };\n}\n/**\n * Create a new project with pre-configured boilerplate\n */\nexport interface NewOptions {\n    /**\n     * The path where the NAPI-RS project will be created.\n     */\n    path?: string;\n    /**\n     * The name of the project, default to the name of the directory if not provided\n     */\n    name?: string;\n    /**\n     * The minimum Node-API version to support\n     *\n     * @default 4\n     */\n    minNodeApiVersion?: number;\n    /**\n     * The package manager to use. Only support yarn 4.x for now.\n     *\n     * @default 'yarn'\n     */\n    packageManager?: string;\n    /**\n     * License for open-sourced project\n     *\n     * @default 'MIT'\n     */\n    license?: string;\n    /**\n     * All targets the crate will be compiled for.\n     *\n     * @default []\n     */\n    targets?: string[];\n    /**\n     * Whether enable default targets\n     *\n     * @default true\n     */\n    enableDefaultTargets?: boolean;\n    /**\n     * Whether enable all targets\n     *\n     * @default false\n     */\n    enableAllTargets?: boolean;\n    /**\n     * Whether enable the `type-def` feature for typescript definitions auto-generation\n     *\n     * @default true\n     */\n    enableTypeDef?: boolean;\n    /**\n     * Whether generate preconfigured GitHub Actions workflow\n     *\n     * @default true\n     */\n    enableGithubActions?: boolean;\n    /**\n     * The JavaScript test framework to use, only support `ava` for now\n     *\n     * @default 'ava'\n     */\n    testFramework?: string;\n    /**\n     * Whether to run the command in dry-run mode\n     *\n     * @default false\n     */\n    dryRun?: boolean;\n}\nexport declare function applyDefaultNewOptions(options: NewOptions): {\n    /**\n     * The path where the NAPI-RS project will be created.\n     */\n    path?: string;\n    /**\n     * The name of the project, default to the name of the directory if not provided\n     */\n    name?: string;\n    minNodeApiVersion: number;\n    packageManager: string;\n    license: string;\n    targets: string[];\n    enableDefaultTargets: boolean;\n    enableAllTargets: boolean;\n    enableTypeDef: boolean;\n    enableGithubActions: boolean;\n    testFramework: string;\n    dryRun: boolean;\n};\n","import { type NewOptions as RawNewOptions } from '../def/new.js';\ntype NewOptions = Required<RawNewOptions>;\nexport declare const GENERATED_WASI_BINDING: RegExp;\nexport declare function updateCargoTomlNodeApiVersion(filePath: string, minNodeApiVersion: number): Promise<void>;\nexport declare function newProject(userOptions: RawNewOptions): Promise<void>;\nexport type { NewOptions };\n","import { Command } from 'clipanion';\nexport declare abstract class BasePrePublishCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    tagStyle: string;\n    ghRelease: boolean;\n    ghReleaseName?: string;\n    ghReleaseId?: string;\n    skipOptionalPublish: boolean;\n    rootPublisher?: 'npm' | 'pnpm' | 'yarn' | 'yarn-classic';\n    dryRun: boolean;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        npmDir: string;\n        tagStyle: string;\n        ghRelease: boolean;\n        ghReleaseName: string | undefined;\n        ghReleaseId: string | undefined;\n        skipOptionalPublish: boolean;\n        rootPublisher: \"yarn\" | \"pnpm\" | \"npm\" | \"yarn-classic\" | undefined;\n        dryRun: boolean;\n    };\n}\n/**\n * Update package.json and copy addons into per platform packages\n */\nexport interface PrePublishOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n    /**\n     * git tag style, `npm` or `lerna`\n     *\n     * @default 'lerna'\n     */\n    tagStyle?: 'npm' | 'lerna';\n    /**\n     * Whether create GitHub release\n     *\n     * @default true\n     */\n    ghRelease?: boolean;\n    /**\n     * GitHub release name\n     */\n    ghReleaseName?: string;\n    /**\n     * Existing GitHub release id\n     */\n    ghReleaseId?: string;\n    /**\n     * Whether skip optionalDependencies packages publish\n     *\n     * @default false\n     */\n    skipOptionalPublish?: boolean;\n    /**\n     * The package manager that publishes the root package. pnpm and yarn berry replace `exports` with `publishConfig.exports` while packing, so for them the root package validation targets the publish-effective export map. Defaults to the `napi.rootPublisher` config field, and validates both export maps when neither is set\n     */\n    rootPublisher?: 'npm' | 'pnpm' | 'yarn' | 'yarn-classic';\n    /**\n     * Dry run without touching file system\n     *\n     * @default false\n     */\n    dryRun?: boolean;\n}\nexport declare function applyDefaultPrePublishOptions(options: PrePublishOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    tagStyle: string;\n    ghRelease: boolean;\n    /**\n     * GitHub release name\n     */\n    ghReleaseName?: string;\n    /**\n     * Existing GitHub release id\n     */\n    ghReleaseId?: string;\n    skipOptionalPublish: boolean;\n    /**\n     * The package manager that publishes the root package. pnpm and yarn berry replace `exports` with `publishConfig.exports` while packing, so for them the root package validation targets the publish-effective export map. Defaults to the `napi.rootPublisher` config field, and validates both export maps when neither is set\n     */\n    rootPublisher?: \"npm\" | \"pnpm\" | \"yarn\" | \"yarn-classic\";\n    dryRun: boolean;\n};\n","import { type PrePublishOptions } from '../def/pre-publish.js';\nimport { type CommonPackageJsonFields, type RootPublisher, type Target, type UserNapiConfig } from '../utils/index.js';\n/**\n * Build the root package's `optionalDependencies` map.\n *\n * A WASI package is a fallback for hosts that cannot load a `.node` binary, and\n * the generated binding loader selects it at require time rather than npm\n * selecting it at install time. Declaring it as an `optionalDependency`\n * alongside the native packages cannot express \"install this only when nothing\n * else matched\": npm evaluates every entry independently, so every consumer\n * downloads a `.wasm` binary they will never load.\n *\n * It is therefore only declared when WASI is the only configured target, which\n * makes it the primary artifact rather than a fallback.\n * `napi.wasm.optionalDependency` overrides the default in both directions.\n *\n * See https://github.com/rolldown/rolldown/issues/10556\n */\nexport declare function resolveRootOptionalDependencies({ existing, managedPackageNames, packageName, targets, version, wasm, }: {\n    existing: unknown;\n    managedPackageNames: Iterable<string>;\n    packageName: string;\n    targets: Target[];\n    version: string;\n    wasm?: UserNapiConfig['wasm'];\n}): Record<string, unknown>;\nexport declare function prePublish(userOptions: PrePublishOptions): Promise<void>;\ninterface ThreadlessWasiRootFacade {\n    exports: Record<string, unknown>;\n    publishConfigExports?: Record<string, unknown>;\n    generatedFiles: string[];\n    files: ThreadlessWasiRootFacadeFiles;\n    wasmSourcePath: string;\n    marker: string;\n    forwardingModule: string;\n    packageJsonUpdate: {\n        files?: string[];\n    };\n}\ninterface ThreadlessWasiRootFacadeFiles {\n    workerdEntry: string;\n    workerdTypeDef: string;\n    wasmEntry: string;\n    wasmTypeDef: string;\n}\nexport declare function rootPublisherRewritesRootExports(rootPublisher: RootPublisher | undefined): boolean;\nexport declare function resolveRootPublisher(optionValue: string | undefined, configValue: string | undefined): RootPublisher | undefined;\nexport declare function sniffRewritingPublisherFromUserAgent(userAgent?: string | undefined): 'pnpm' | 'yarn' | undefined;\nexport declare function rootPublisherHint(rootPublisher: RootPublisher | undefined, userAgent?: string): string;\nexport declare function collectRootPackagePathReferences(packageJson: CommonPackageJsonFields, rootPublisher?: RootPublisher): string[];\nexport declare function parseNpmPackFiles(output: string): Set<string>;\nexport declare function validateRootFacadePacklist(rootDir: string, rootPackageFiles: string[], rootPublisher?: RootPublisher): void;\ninterface RootReleaseMaterializationPlan {\n    packageJson: CommonPackageJsonFields;\n    optionalDependencies: Record<string, unknown>;\n    nodeEngine?: string;\n    facade?: ThreadlessWasiRootFacade;\n    staleGeneratedFiles: string[];\n    rootPublisher?: RootPublisher;\n}\ninterface ReleasePackageMaterializationPlan {\n    target: Target;\n    pkgDir: string;\n    rootDir: string;\n    stagedPkgDir?: string;\n    packageFiles: string[];\n    declarationDependencies: string[];\n    updateManifest: boolean;\n}\ninterface CommitPrePublishFileSystemTransactionOptions {\n    packageJsonPath: string;\n    releasePackagePlans: ReleasePackageMaterializationPlan[];\n    rootDir: string;\n    rootReleasePlan: RootReleaseMaterializationPlan;\n    stagedRootManifestPath?: string;\n    stagedRootDir: string;\n    transactionRoot?: string;\n}\nexport declare function commitPrePublishFileSystemTransaction({ packageJsonPath, releasePackagePlans, rootDir, rootReleasePlan, stagedRootDir, stagedRootManifestPath, transactionRoot, }: CommitPrePublishFileSystemTransactionOptions): Promise<void>;\nexport {};\n","import { Command } from 'clipanion';\nexport declare abstract class BaseRenameCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    $$name?: string;\n    binaryName?: string;\n    packageName?: string;\n    manifestPath: string;\n    repository?: string;\n    description?: string;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        npmDir: string;\n        name: string | undefined;\n        binaryName: string | undefined;\n        packageName: string | undefined;\n        manifestPath: string;\n        repository: string | undefined;\n        description: string | undefined;\n    };\n}\n/**\n * Rename the NAPI-RS project\n */\nexport interface RenameOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n    /**\n     * The new name of the project\n     */\n    name?: string;\n    /**\n     * The new binary name *.node files\n     */\n    binaryName?: string;\n    /**\n     * The new package name of the project\n     */\n    packageName?: string;\n    /**\n     * Path to `Cargo.toml`\n     *\n     * @default 'Cargo.toml'\n     */\n    manifestPath?: string;\n    /**\n     * The new repository of the project\n     */\n    repository?: string;\n    /**\n     * The new description of the project\n     */\n    description?: string;\n}\nexport declare function applyDefaultRenameOptions(options: RenameOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    /**\n     * The new name of the project\n     */\n    name?: string;\n    /**\n     * The new binary name *.node files\n     */\n    binaryName?: string;\n    /**\n     * The new package name of the project\n     */\n    packageName?: string;\n    manifestPath: string;\n    /**\n     * The new repository of the project\n     */\n    repository?: string;\n    /**\n     * The new description of the project\n     */\n    description?: string;\n};\n","import { type RenameOptions } from '../def/rename.js';\nexport declare function renameProject(userOptions: RenameOptions): Promise<void>;\n","import { Command } from 'clipanion';\nexport declare abstract class BaseUniversalizeCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    outputDir: string;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        outputDir: string;\n    };\n}\n/**\n * Combile built binaries into one universal binary\n */\nexport interface UniversalizeOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where all built `.node` files put, same as `--output-dir` of build command\n     *\n     * @default './'\n     */\n    outputDir?: string;\n}\nexport declare function applyDefaultUniversalizeOptions(options: UniversalizeOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    outputDir: string;\n};\n","import { type UniversalizeOptions } from '../def/universalize.js';\nexport declare function universalizeBinaries(userOptions: UniversalizeOptions): Promise<void>;\n","import { Command } from 'clipanion';\nexport declare abstract class BaseVersionCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        npmDir: string;\n    };\n}\n/**\n * Update version in created npm packages\n */\nexport interface VersionOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n}\nexport declare function applyDefaultVersionOptions(options: VersionOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n};\n","import { type VersionOptions } from '../def/version.js';\nexport declare function version(userOptions: VersionOptions): Promise<void>;\n","import { BaseArtifactsCommand } from '../def/artifacts.js';\nexport declare class ArtifactsCommand extends BaseArtifactsCommand {\n    static usage: import(\"clipanion\").Usage;\n    static paths: string[][];\n    execute(): Promise<void>;\n}\n","import { BaseBuildCommand } from '../def/build.js';\nexport declare class BuildCommand extends BaseBuildCommand {\n    pipe: string | undefined;\n    cargoOptions: string[];\n    execute(): Promise<void>;\n}\n","import { BaseCreateNpmDirsCommand } from '../def/create-npm-dirs.js';\nexport declare class CreateNpmDirsCommand extends BaseCreateNpmDirsCommand {\n    execute(): Promise<void>;\n}\n","import { BaseNewCommand } from '../def/new.js';\nexport declare function getNapiVersionChoices(): {\n    name: string;\n    value: import(\"../utils/version.js\").NapiVersion;\n}[];\nexport declare class NewCommand extends BaseNewCommand {\n    interactive: boolean;\n    execute(): Promise<0 | 1>;\n    private fetchOptions;\n    private fetchName;\n    private fetchLicense;\n    private fetchNapiVersion;\n    private fetchTargets;\n    private fetchTypeDef;\n    private fetchGithubActions;\n}\n","import { BasePrePublishCommand } from '../def/pre-publish.js';\nexport declare class PrePublishCommand extends BasePrePublishCommand {\n    execute(): Promise<void>;\n}\n","import { BaseRenameCommand } from '../def/rename.js';\nexport declare class RenameCommand extends BaseRenameCommand {\n    execute(): Promise<void>;\n}\n","import { BaseUniversalizeCommand } from '../def/universalize.js';\nexport declare class UniversalizeCommand extends BaseUniversalizeCommand {\n    execute(): Promise<void>;\n}\n","import { BaseVersionCommand } from '../def/version.js';\nexport declare class VersionCommand extends BaseVersionCommand {\n    execute(): Promise<void>;\n}\n","import { Cli } from 'clipanion';\nimport { collectArtifacts } from './api/artifacts.js';\nimport { buildProject } from './api/build.js';\nimport { createNpmDirs } from './api/create-npm-dirs.js';\nimport { newProject } from './api/new.js';\nimport { prePublish } from './api/pre-publish.js';\nimport { renameProject } from './api/rename.js';\nimport { universalizeBinaries } from './api/universalize.js';\nimport { version } from './api/version.js';\nimport { ArtifactsCommand } from './commands/artifacts.js';\nimport { BuildCommand } from './commands/build.js';\nimport { CreateNpmDirsCommand } from './commands/create-npm-dirs.js';\nimport { NewCommand } from './commands/new.js';\nimport { PrePublishCommand } from './commands/pre-publish.js';\nimport { RenameCommand } from './commands/rename.js';\nimport { UniversalizeCommand } from './commands/universalize.js';\nimport { VersionCommand } from './commands/version.js';\nexport declare const cli: Cli<import(\"clipanion\").BaseContext>;\n/**\n *\n * @usage\n *\n * ```ts\n * const cli = new NapiCli()\n *\n * cli.build({\n *   cwd: '/path/to/your/project',\n * })\n * ```\n */\nexport declare class NapiCli {\n    artifacts: typeof collectArtifacts;\n    new: typeof newProject;\n    build: typeof buildProject;\n    createNpmDirs: typeof createNpmDirs;\n    prePublish: typeof prePublish;\n    rename: typeof renameProject;\n    universalize: typeof universalizeBinaries;\n    version: typeof version;\n}\nexport declare function createBuildCommand(args: string[]): BuildCommand;\nexport declare function createArtifactsCommand(args: string[]): ArtifactsCommand;\nexport declare function createCreateNpmDirsCommand(args: string[]): CreateNpmDirsCommand;\nexport declare function createPrePublishCommand(args: string[]): PrePublishCommand;\nexport declare function createRenameCommand(args: string[]): RenameCommand;\nexport declare function createUniversalizeCommand(args: string[]): UniversalizeCommand;\nexport declare function createVersionCommand(args: string[]): VersionCommand;\nexport declare function createNewCommand(args: string[]): NewCommand;\nexport { parseTriple } from './utils/target.js';\nexport { type GenerateTypeDefOptions, type WriteJsBindingOptions, writeJsBinding, generateTypeDef, } from './api/build.js';\nexport { readNapiConfig } from './utils/config.js';\n"],"mappings":"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"}
+export type { GenerateTypeDefOptions, WriteJsBindingOptions };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.d.ts","names":["BuildOptions","RawBuildOptions","RawNewOptions","version","version"],"sources":["../src/def/artifacts.d.ts","../src/api/artifacts.d.ts","../src/def/build.d.ts","../src/utils/log.d.ts","../src/utils/target.d.ts","../src/utils/config.d.ts","../src/api/build.d.ts","../src/def/create-npm-dirs.d.ts","../src/api/create-npm-dirs.d.ts","../src/def/new.d.ts","../src/api/new.d.ts","../src/def/pre-publish.d.ts","../src/api/pre-publish.d.ts","../src/def/rename.d.ts","../src/api/rename.d.ts","../src/def/universalize.d.ts","../src/api/universalize.d.ts","../src/def/version.d.ts","../src/api/version.d.ts","../src/commands/artifacts.d.ts","../src/commands/build.d.ts","../src/commands/create-npm-dirs.d.ts","../src/commands/new.d.ts","../src/commands/pre-publish.d.ts","../src/commands/rename.d.ts","../src/commands/universalize.d.ts","../src/commands/version.d.ts","../src/index.d.ts"],"sourcesContent":["import { Command } from 'clipanion';\nexport declare abstract class BaseArtifactsCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    outputDir: string;\n    npmDir: string;\n    buildOutputDir?: string;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        outputDir: string;\n        npmDir: string;\n        buildOutputDir: string | undefined;\n    };\n}\n/**\n * Copy artifacts from Github Actions into npm packages and ready to publish\n */\nexport interface ArtifactsOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where all built `.node` files put, same as `--output-dir` of build command\n     *\n     * @default './artifacts'\n     */\n    outputDir?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n    /**\n     * Path to the build output dir, only needed when targets contain a WASI target\n     */\n    buildOutputDir?: string;\n}\nexport declare function applyDefaultArtifactsOptions(options: ArtifactsOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    outputDir: string;\n    npmDir: string;\n    /**\n     * Path to the build output dir, only needed when targets contain a WASI target\n     */\n    buildOutputDir?: string;\n};\n","import { type ArtifactsOptions } from '../def/artifacts.js';\nexport declare function collectArtifacts(userOptions: ArtifactsOptions): Promise<void>;\n","import { Command } from 'clipanion';\nexport declare abstract class BaseBuildCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    target?: string;\n    cwd?: string;\n    manifestPath?: string;\n    configPath?: string;\n    packageJsonPath?: string;\n    targetDir?: string;\n    outputDir?: string;\n    platform?: boolean;\n    jsPackageName?: string;\n    constEnum?: boolean;\n    runtimeStringEnum?: boolean;\n    jsBinding?: string;\n    noJsBinding?: boolean;\n    dts?: string;\n    dtsHeader?: string;\n    noDtsHeader?: boolean;\n    dtsCache: boolean;\n    format?: 'esm' | 'commonjs';\n    esm?: boolean;\n    commonjs?: boolean;\n    strip?: boolean;\n    release?: boolean;\n    verbose?: boolean;\n    bin?: string;\n    package?: string;\n    profile?: string;\n    crossCompile?: boolean;\n    useCross?: boolean;\n    useNapiCross?: boolean;\n    watch?: boolean;\n    features?: string[];\n    allFeatures?: boolean;\n    noDefaultFeatures?: boolean;\n    /**\n     * Return the parsed build options.\n     */\n    getOptions(): {\n        target: string | undefined;\n        cwd: string | undefined;\n        manifestPath: string | undefined;\n        configPath: string | undefined;\n        packageJsonPath: string | undefined;\n        targetDir: string | undefined;\n        outputDir: string | undefined;\n        platform: boolean | undefined;\n        jsPackageName: string | undefined;\n        constEnum: boolean | undefined;\n        runtimeStringEnum: boolean | undefined;\n        jsBinding: string | undefined;\n        noJsBinding: boolean | undefined;\n        dts: string | undefined;\n        dtsHeader: string | undefined;\n        noDtsHeader: boolean | undefined;\n        dtsCache: boolean;\n        format: \"esm\" | \"commonjs\" | undefined;\n        esm: boolean | undefined;\n        commonjs: boolean | undefined;\n        strip: boolean | undefined;\n        release: boolean | undefined;\n        verbose: boolean | undefined;\n        bin: string | undefined;\n        package: string | undefined;\n        profile: string | undefined;\n        crossCompile: boolean | undefined;\n        useCross: boolean | undefined;\n        useNapiCross: boolean | undefined;\n        watch: boolean | undefined;\n        features: string[] | undefined;\n        allFeatures: boolean | undefined;\n        noDefaultFeatures: boolean | undefined;\n    };\n}\n/**\n * Build the NAPI-RS project\n */\nexport interface BuildOptions {\n    /**\n     * Build for the target triple, bypassed to `cargo build --target`\n     */\n    target?: string;\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     */\n    cwd?: string;\n    /**\n     * Path to `Cargo.toml`\n     */\n    manifestPath?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     */\n    packageJsonPath?: string;\n    /**\n     * Directory for all crate generated artifacts, see `cargo build --target-dir`\n     */\n    targetDir?: string;\n    /**\n     * Path to where all the built files would be put. Default to the crate folder\n     */\n    outputDir?: string;\n    /**\n     * Add platform triple to the generated nodejs binding file, eg: `[name].linux-x64-gnu.node`\n     */\n    platform?: boolean;\n    /**\n     * Package name in generated js binding file. Only works with `--platform` flag\n     */\n    jsPackageName?: string;\n    /**\n     * Whether generate const enum for typescript bindings\n     */\n    constEnum?: boolean;\n    /**\n     * Emit `#[napi(string_enum)]` enums as runtime enums (`export declare enum`) under `--no-const-enum`. Default: type-only union.\n     */\n    runtimeStringEnum?: boolean;\n    /**\n     * Path and filename of generated JS binding file. Only works with `--platform` flag. Relative to `--output-dir`.\n     */\n    jsBinding?: string;\n    /**\n     * Whether to disable the generation JS binding file. Only works with `--platform` flag.\n     */\n    noJsBinding?: boolean;\n    /**\n     * Path and filename of generated type def file. Relative to `--output-dir`\n     */\n    dts?: string;\n    /**\n     * Custom file header for generated type def file. Only works when `typedef` feature enabled.\n     */\n    dtsHeader?: string;\n    /**\n     * Whether to disable the default file header for generated type def file. Only works when `typedef` feature enabled.\n     */\n    noDtsHeader?: boolean;\n    /**\n     * Whether to enable the dts cache, default to true\n     *\n     * @default true\n     */\n    dtsCache?: boolean;\n    /**\n     * The module format of the generated JS binding file. Only works with `--platform` flag. Defaults to `commonjs`.\n     */\n    format?: 'esm' | 'commonjs';\n    /**\n     * Alias for `--format esm`.\n     */\n    esm?: boolean;\n    /**\n     * Alias for `--format commonjs`.\n     */\n    commonjs?: boolean;\n    /**\n     * Whether strip the library to achieve the minimum file size\n     */\n    strip?: boolean;\n    /**\n     * Build in release mode\n     */\n    release?: boolean;\n    /**\n     * Verbosely log build command trace\n     */\n    verbose?: boolean;\n    /**\n     * Build only the specified binary\n     */\n    bin?: string;\n    /**\n     * Build the specified library or the one at cwd\n     */\n    package?: string;\n    /**\n     * Build artifacts with the specified profile\n     */\n    profile?: string;\n    /**\n     * [experimental] cross compile by replacing the cargo subcommand: Windows MSVC targets from a non-Windows host build with `cargo-xwin` (`windows-gnu` targets are rejected, `cargo-xwin` cannot handle them), non-Windows targets build with `cargo-zigbuild` (requires `zig` on PATH). The selected subcommand is auto-installed on first use. Cannot be combined with `--use-cross`, `--use-napi-cross` or `--watch`\n     */\n    crossCompile?: boolean;\n    /**\n     * [experimental] not recommended, prefer `--cross-compile` or `--use-napi-cross`: build in a Docker or Podman container with [cross](https://github.com/cross-rs/cross), which must be installed manually and needs a running container engine. Cannot be combined with `--cross-compile`, `--use-napi-cross` or `--watch`\n     */\n    useCross?: boolean;\n    /**\n     * [experimental] download a prebuilt gcc cross toolchain from `@napi-rs/cross-toolchain` (glibc 2.17) and set linker and C compiler environment variables. Linux glibc targets only (x64, arm64, armv7, ppc64le, s390x) on a Linux x64 or arm64 host, any other target or host errors. Cannot be combined with `--cross-compile` or `--use-cross`\n     */\n    useNapiCross?: boolean;\n    /**\n     * watch the crate changes and build continuously with `cargo-watch` crates\n     */\n    watch?: boolean;\n    /**\n     * Space-separated list of features to activate\n     */\n    features?: string[];\n    /**\n     * Activate all available features\n     */\n    allFeatures?: boolean;\n    /**\n     * Do not activate the `default` feature\n     */\n    noDefaultFeatures?: boolean;\n}\nexport declare function applyDefaultBuildOptions(options: BuildOptions): {\n    /**\n     * Build for the target triple, bypassed to `cargo build --target`\n     */\n    target?: string;\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     */\n    cwd?: string;\n    /**\n     * Path to `Cargo.toml`\n     */\n    manifestPath?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     */\n    packageJsonPath?: string;\n    /**\n     * Directory for all crate generated artifacts, see `cargo build --target-dir`\n     */\n    targetDir?: string;\n    /**\n     * Path to where all the built files would be put. Default to the crate folder\n     */\n    outputDir?: string;\n    /**\n     * Add platform triple to the generated nodejs binding file, eg: `[name].linux-x64-gnu.node`\n     */\n    platform?: boolean;\n    /**\n     * Package name in generated js binding file. Only works with `--platform` flag\n     */\n    jsPackageName?: string;\n    /**\n     * Whether generate const enum for typescript bindings\n     */\n    constEnum?: boolean;\n    /**\n     * Emit `#[napi(string_enum)]` enums as runtime enums (`export declare enum`) under `--no-const-enum`. Default: type-only union.\n     */\n    runtimeStringEnum?: boolean;\n    /**\n     * Path and filename of generated JS binding file. Only works with `--platform` flag. Relative to `--output-dir`.\n     */\n    jsBinding?: string;\n    /**\n     * Whether to disable the generation JS binding file. Only works with `--platform` flag.\n     */\n    noJsBinding?: boolean;\n    /**\n     * Path and filename of generated type def file. Relative to `--output-dir`\n     */\n    dts?: string;\n    /**\n     * Custom file header for generated type def file. Only works when `typedef` feature enabled.\n     */\n    dtsHeader?: string;\n    /**\n     * Whether to disable the default file header for generated type def file. Only works when `typedef` feature enabled.\n     */\n    noDtsHeader?: boolean;\n    dtsCache: boolean;\n    /**\n     * The module format of the generated JS binding file. Only works with `--platform` flag. Defaults to `commonjs`.\n     */\n    format?: \"esm\" | \"commonjs\";\n    /**\n     * Alias for `--format esm`.\n     */\n    esm?: boolean;\n    /**\n     * Alias for `--format commonjs`.\n     */\n    commonjs?: boolean;\n    /**\n     * Whether strip the library to achieve the minimum file size\n     */\n    strip?: boolean;\n    /**\n     * Build in release mode\n     */\n    release?: boolean;\n    /**\n     * Verbosely log build command trace\n     */\n    verbose?: boolean;\n    /**\n     * Build only the specified binary\n     */\n    bin?: string;\n    /**\n     * Build the specified library or the one at cwd\n     */\n    package?: string;\n    /**\n     * Build artifacts with the specified profile\n     */\n    profile?: string;\n    /**\n     * [experimental] cross compile by replacing the cargo subcommand: Windows MSVC targets from a non-Windows host build with `cargo-xwin` (`windows-gnu` targets are rejected, `cargo-xwin` cannot handle them), non-Windows targets build with `cargo-zigbuild` (requires `zig` on PATH). The selected subcommand is auto-installed on first use. Cannot be combined with `--use-cross`, `--use-napi-cross` or `--watch`\n     */\n    crossCompile?: boolean;\n    /**\n     * [experimental] not recommended, prefer `--cross-compile` or `--use-napi-cross`: build in a Docker or Podman container with [cross](https://github.com/cross-rs/cross), which must be installed manually and needs a running container engine. Cannot be combined with `--cross-compile`, `--use-napi-cross` or `--watch`\n     */\n    useCross?: boolean;\n    /**\n     * [experimental] download a prebuilt gcc cross toolchain from `@napi-rs/cross-toolchain` (glibc 2.17) and set linker and C compiler environment variables. Linux glibc targets only (x64, arm64, armv7, ppc64le, s390x) on a Linux x64 or arm64 host, any other target or host errors. Cannot be combined with `--cross-compile` or `--use-cross`\n     */\n    useNapiCross?: boolean;\n    /**\n     * watch the crate changes and build continuously with `cargo-watch` crates\n     */\n    watch?: boolean;\n    /**\n     * Space-separated list of features to activate\n     */\n    features?: string[];\n    /**\n     * Activate all available features\n     */\n    allFeatures?: boolean;\n    /**\n     * Do not activate the `default` feature\n     */\n    noDefaultFeatures?: boolean;\n};\n","declare module 'obug' {\n    interface Debugger {\n        info: typeof console.error;\n        warn: typeof console.error;\n        error: typeof console.error;\n    }\n}\nexport declare const debugFactory: (namespace: string) => import(\"obug\").Debugger;\nexport declare const debug: import(\"obug\").Debugger;\n","export type Platform = NodeJS.Platform | 'wasm' | 'wasi' | 'openharmony';\nexport declare const UNIVERSAL_TARGETS: {\n    readonly 'universal-apple-darwin': readonly [\"aarch64-apple-darwin\", \"x86_64-apple-darwin\"];\n};\nexport declare const AVAILABLE_TARGETS: readonly [\"aarch64-apple-darwin\", \"aarch64-linux-android\", \"aarch64-unknown-linux-gnu\", \"aarch64-unknown-linux-musl\", \"aarch64-unknown-linux-ohos\", \"aarch64-pc-windows-msvc\", \"x86_64-apple-darwin\", \"x86_64-pc-windows-msvc\", \"x86_64-pc-windows-gnu\", \"x86_64-unknown-linux-gnu\", \"x86_64-unknown-linux-musl\", \"x86_64-unknown-linux-ohos\", \"x86_64-unknown-freebsd\", \"i686-pc-windows-msvc\", \"armv7-unknown-linux-gnueabihf\", \"armv7-unknown-linux-musleabihf\", \"armv7-linux-androideabi\", \"universal-apple-darwin\", \"loongarch64-unknown-linux-gnu\", \"riscv64gc-unknown-linux-gnu\", \"powerpc64le-unknown-linux-gnu\", \"s390x-unknown-linux-gnu\", \"wasm32-wasip1\", \"wasm32-wasip1-threads\"];\nexport type TargetTriple = (typeof AVAILABLE_TARGETS)[number];\nexport declare const DEFAULT_TARGETS: readonly [\"x86_64-apple-darwin\", \"aarch64-apple-darwin\", \"x86_64-pc-windows-msvc\", \"x86_64-unknown-linux-gnu\"];\nexport declare const TARGET_LINKER: Record<string, string>;\ntype NodeJSArch = 'arm' | 'arm64' | 'ia32' | 'loong64' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 'riscv64' | 's390' | 's390x' | 'x32' | 'x64' | 'universal' | 'wasm32';\nexport declare const NodeArchToCpu: Record<string, string>;\nexport declare const UniArchsByPlatform: Partial<Record<Platform, NodeJSArch[]>>;\nexport interface Target {\n    triple: string;\n    platformArchABI: string;\n    platform: Platform;\n    arch: NodeJSArch;\n    abi: string | null;\n}\nexport type WasiFlavor = 'single' | 'threads';\nexport interface WasiTarget {\n    canonicalTriple: string;\n    flavor: WasiFlavor;\n    platformArchABI: string;\n}\n/**\n * Resolve historical WASI spellings to one build target and one artifact\n * identity. `wasm32-wasi` historically produced the threaded package, so it\n * must never be inferred as threadless merely because its name lacks the\n * `-threads` suffix.\n */\nexport declare function getWasiTarget(target: string | Pick<Target, 'triple'>): WasiTarget | undefined;\nexport declare function wasiTargetHasThreads(target: string | Pick<Target, 'triple'>): boolean;\n/**\n * Detect the major version of a wasi-sdk installation.\n *\n * wasi-libc dropped the unused `int op` parameter from\n * `__wasilibc_futex_wait_atomic_wait` and `__wasilibc_futex_wait_maybe_busy`,\n * and wasi-sdk 34 is the first release that ships the 3-argument signature.\n * Static archives compiled against the two signatures cannot be mixed, so the\n * emnapi archives have to be picked by wasi-sdk version, not by target triple\n * alone.\n *\n * `<wasiSdkPath>/VERSION` is the primary signal: every release ships it and\n * its first line is the version (`27.0`, `33.0+m`, `34.0`, ...). The\n * `wasi/version.h` header carrying `__wasi_sdk_major__` only appears from\n * wasi-sdk 30 onwards, so it stays a fallback for trees without a `VERSION`.\n *\n * Returns `null` when neither signal is readable or parseable. Detection must\n * never throw: an unknown wasi-sdk degrades to the legacy archives instead of\n * failing the build.\n */\nexport declare function wasiSdkMajorVersion(wasiSdkPath: string): number | null;\n/**\n * Path to the wasi-libc that cargo links when no wasi-sdk is configured.\n *\n * Without `WASI_SDK_PATH` the target links through `rust-lld` against the\n * wasi-libc bundled with the Rust standard library, so that copy — not a\n * wasi-sdk — decides the futex ABI.\n *\n * `cwd` must be the directory Cargo is spawned in, because that is what\n * selects the toolchain.\n *\n * Returns `null` when `rustc` cannot be queried or the target is not\n * installed. Never throws: an undetectable sysroot degrades to the legacy\n * archives.\n */\nexport declare function rustBundledWasiLibc(wasiTarget: string, cwd?: string): string | null;\n/**\n * Whether a wasi-libc archive carries the 3-argument futex ABI.\n *\n * Returns `null` when the archive cannot be read, so callers can tell\n * \"definitely the legacy ABI\" apart from \"could not tell\".\n */\nexport declare function wasiLibcHasNewFutexAbi(libcArchivePath: string | null): boolean | null;\n/**\n * A triple is a specific format for specifying a target architecture.\n * Triples may be referred to as a target triple which is the architecture for the artifact produced, and the host triple which is the architecture that the compiler is running on.\n * The general format of the triple is `<arch><sub>-<vendor>-<sys>-<abi>` where:\n *   - `arch` = The base CPU architecture, for example `x86_64`, `i686`, `arm`, `thumb`, `mips`, etc.\n *   - `sub` = The CPU sub-architecture, for example `arm` has `v7`, `v7s`, `v5te`, etc.\n *   - `vendor` = The vendor, for example `unknown`, `apple`, `pc`, `nvidia`, etc.\n *   - `sys` = The system name, for example `linux`, `windows`, `darwin`, etc. none is typically used for bare-metal without an OS.\n *   - `abi` = The ABI, for example `gnu`, `android`, `eabi`, etc.\n */\nexport declare function parseTriple(rawTriple: string): Target;\nexport declare function getSystemDefaultTarget(): Target;\nexport declare function getTargetLinker(target: string): string | undefined;\n/**\n * Loader-file suffix for a WASI flavor, derived from its `platformArchABI`:\n * the legacy threaded flavor keeps the historical `wasi` stem\n * (`<binaryName>.wasi.cjs`, `<binaryName>.wasi-browser.js`), while each\n * distinctly named non-threaded flavor derives its own\n * (`<binaryName>.wasip1.cjs`, `<binaryName>.wasip1-browser.js`, ...).\n */\nexport declare function wasiLoaderSuffix(platformArchABI: string): string;\nexport declare function targetToEnvVar(target: string): string;\nexport {};\n","import { type Target } from './target.js';\nexport type ValueOfConstArray<T> = T[Exclude<keyof T, keyof Array<any>>];\nexport declare const SupportedPackageManagers: readonly [\"yarn\", \"pnpm\"];\nexport declare const SupportedTestFrameworks: readonly [\"ava\"];\nexport type SupportedPackageManager = ValueOfConstArray<typeof SupportedPackageManagers>;\nexport type SupportedTestFramework = ValueOfConstArray<typeof SupportedTestFrameworks>;\n/**\n * Package managers that may publish the **root** package, distinguished by\n * whether they rewrite the manifest while packing it.\n *\n * `yarn` means yarn berry (>= 2); Yarn Classic (1.x) packs the raw manifest\n * like npm does and is spelled `yarn-classic`.\n */\nexport declare const RootPublishers: readonly [\"npm\", \"pnpm\", \"yarn\", \"yarn-classic\"];\nexport type RootPublisher = ValueOfConstArray<typeof RootPublishers>;\nexport interface UserNapiConfig {\n    /**\n     * Name of the binary to be generated, default to `index`\n     */\n    binaryName?: string;\n    /**\n     * Name of the npm package, default to the name of root package.json name\n     *\n     * Always given `@scope/pkg` and arch suffix will be appended like `@scope/pkg-linux-gnu-x64`\n     */\n    packageName?: string;\n    /**\n     * All targets the crate will be compiled for\n     */\n    targets?: string[];\n    /**\n     * The npm client project uses.\n     */\n    npmClient?: string;\n    /**\n     * The package manager that publishes the **root** package.\n     *\n     * `napi pre-publish` publishes only the generated per-platform packages; the\n     * root package is packed and published by the caller, so this cannot be\n     * inferred reliably. pnpm and yarn berry replace `exports` with\n     * `publishConfig.exports` while packing, so under those publishers\n     * `napi pre-publish` validates only the publish-effective export map and the\n     * local `exports` may point at development-only sources. npm and Yarn\n     * Classic ship `exports` untouched.\n     *\n     * Unset — the default — validates both maps, which is correct for every\n     * publisher but rejects development-only conditions such as\n     * `\"dev\": \"./src/index.ts\"`.\n     */\n    rootPublisher?: RootPublisher;\n    /**\n     * Whether generate const enum for typescript bindings\n     */\n    constEnum?: boolean;\n    /**\n     * Emit `#[napi(string_enum)]` enums as runtime enums (`export declare enum`) under `--no-const-enum`. Default: type-only union.\n     */\n    runtimeStringEnum?: boolean;\n    /**\n     * dts header prepend to the generated dts file\n     */\n    dtsHeader?: string;\n    /**\n     * dts header file path to be prepended to the generated dts file\n     * if both dtsHeader and dtsHeaderFile are provided, dtsHeaderFile will be used\n     */\n    dtsHeaderFile?: string;\n    /**\n     * wasm compilation options\n     */\n    wasm?: {\n        /**\n         * https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface/Memory\n         * @default 4000 pages (250 MiB), or 1024 pages (64 MiB) for the deferred workerd loader\n         */\n        initialMemory?: number;\n        /**\n         * Initial linear memory, in 64 KiB pages, for the **threadless**\n         * (`wasm32-wasip1`) loaders only: the Node CJS loader, the browser loader\n         * and the deferred `./workerd` loader.\n         *\n         * The threaded loaders allocate one `shared: true` memory that every\n         * wasi-threads worker maps, so every worker stack and every thread's\n         * allocations come out of it and growing it is a cross-thread event; it is\n         * sized for the whole pool up front. The threadless loaders drive a single\n         * thread through a plain growable `ArrayBuffer`: they only have to clear\n         * the module's own link-time floor (`-zstack-size` plus static data) and\n         * grow on demand, which is what lets the same build fit a host with a hard\n         * isolate cap such as workerd's 128 MiB.\n         *\n         * Falls back to `initialMemory` when unset, so existing projects are\n         * unaffected.\n         *\n         * @default `initialMemory` (4000 pages), or 1024 pages for the deferred\n         *   `./workerd` loader\n         */\n        threadlessInitialMemory?: number;\n        /**\n         * @default 65536 pages (4GiB)\n         */\n        maximumMemory?: number;\n        /**\n         * Whether the generated `<packageName>-wasm32-wasi` package is declared as\n         * an `optionalDependency` of the root package.\n         *\n         * When native targets are configured the WASI package is a fallback for\n         * hosts that cannot load a `.node` binary, so declaring it would make every\n         * consumer download the `.wasm` binary they will never load. It is\n         * therefore omitted by default and is expected to be installed on demand by\n         * the environments that need it.\n         *\n         * When WASI is the only configured target it is the primary artifact and is\n         * declared by default.\n         *\n         * Set this explicitly to override either default.\n         *\n         * @default true when every configured target is WASI, false otherwise\n         */\n        optionalDependency?: boolean;\n        /**\n         * Whether the generated WASI loaders bootstrap the `napi-async-runtime`\n         * CurrentThread JavaScript hosts.\n         *\n         * A binding built with the `napi-async-runtime` crate runs the\n         * `CurrentThread` flavor on every WebAssembly target (it is the only\n         * flavor there). Its futures make no progress until a task host is\n         * registered, and its timers never fire until a timer host is, so the\n         * loader must install both right after instantiation and unregister them\n         * before the environment is destroyed.\n         *\n         * Enabling this emits that bootstrap in the node, browser and deferred\n         * (workerd) loaders, and declares `@napi-rs/async-runtime` in the\n         * generated `<packageName>-wasm32-*` packages. The loader delegates the\n         * whole host contract — the seven exports, contract version 4, the\n         * reservation identity, the liveness probe and the rollback — to that\n         * package, so a binding that does not actually expose the contract fails\n         * loudly at load with `ERR_NAPI_ASYNC_RUNTIME_BINDING_MISMATCH`.\n         *\n         * The bootstrap runs after instantiation, so after `#[module_init]`: the\n         * host registration functions are exports of the binding itself. Code that\n         * runs during module registration must not create timers (`sleep_until`\n         * fails loud at creation without a timer host) and cannot expect task\n         * progress until the loader has returned.\n         *\n         * @default false\n         */\n        asyncRuntime?: boolean;\n        /**\n         * Browser wasm binding configuration\n         */\n        browser?: {\n            /**\n             * Whether to use fs module in browser\n             */\n            fs?: boolean;\n            /**\n             * Whether to initialize wasm asynchronously\n             */\n            asyncInit?: boolean;\n            /**\n             * Whether to inject `buffer` to emnapi context\n             */\n            buffer?: boolean;\n            /**\n             * Whether to emit custom events for errors in worker\n             */\n            errorEvent?: boolean;\n        };\n    };\n    /**\n     * @deprecated binaryName instead\n     */\n    name?: string;\n    /**\n     * @deprecated use packageName instead\n     */\n    package?: {\n        name?: string;\n    };\n    /**\n     * @deprecated use targets instead\n     */\n    triples?: {\n        /**\n         * Whether enable default targets\n         */\n        defaults: boolean;\n        /**\n         * Additional targets to be compiled for\n         */\n        additional?: string[];\n    };\n}\nexport interface CommonPackageJsonFields {\n    name: string;\n    version: string;\n    description?: string;\n    keywords?: string[];\n    author?: string;\n    authors?: string[];\n    license?: string;\n    cpu?: string[];\n    os?: string[];\n    libc?: string[];\n    files?: string[];\n    repository?: any;\n    homepage?: any;\n    engines?: Record<string, string>;\n    publishConfig?: any;\n    bugs?: any;\n    napi?: UserNapiConfig;\n    type?: 'module' | 'commonjs';\n    scripts?: Record<string, string>;\n    main?: string;\n    module?: string;\n    types?: string;\n    browser?: string;\n    exports?: any;\n    dependencies?: Record<string, string>;\n    devDependencies?: Record<string, string>;\n    optionalDependencies?: Record<string, string>;\n    ava?: {\n        timeout?: string;\n    };\n}\nexport type NapiConfig = Required<Pick<UserNapiConfig, 'binaryName' | 'packageName' | 'npmClient'>> & Pick<UserNapiConfig, 'wasm' | 'dtsHeader' | 'dtsHeaderFile' | 'constEnum' | 'runtimeStringEnum' | 'rootPublisher'> & {\n    targets: Target[];\n    packageJson: CommonPackageJsonFields;\n};\nexport declare function readNapiConfig(path: string, configPath?: string): Promise<NapiConfig>;\n","import type { BuildOptions as RawBuildOptions } from '../def/build.js';\nimport { type NapiConfig, type Target, type CargoWorkspaceMetadata } from '../utils/index.js';\ntype OutputKind = 'js' | 'dts' | 'node' | 'exe' | 'wasm';\ntype Output = {\n    kind: OutputKind;\n    path: string;\n};\nexport type BuildFormat = 'esm' | 'commonjs';\ntype BuildOptions = RawBuildOptions & {\n    cargoOptions?: string[];\n};\nexport declare const WASI_ARTIFACT_METADATA_PREFIX = \"// napi-rs-artifact-metadata:\";\nexport interface AsyncRuntimeHostContractInput {\n    /** The addon's export names, as reported by the type definition pass. */\n    idents: string[];\n    /** Whether `napi.wasm.asyncRuntime` is on. */\n    asyncRuntime: boolean;\n    /**\n     * Whether `idents` is real export metadata. `napi-derive` without its\n     * `type-def` feature emits no type definitions, so the ident list is empty\n     * for every such addon — including one that does export the whole host\n     * contract. An empty list is only evidence when this is `true`.\n     */\n    typeDefAvailable: boolean;\n    packageName: string;\n}\n/**\n * Cross-check `napi.wasm.asyncRuntime` against the addon's export list.\n *\n * Returns the message to throw (`error`) or to log (`warning`), if any. With\n * no type-def metadata there is nothing to check against, so the build says so\n * and defers to the loader's own runtime detection.\n */\nexport declare function checkAsyncRuntimeHostContract({ idents, asyncRuntime, typeDefAvailable, packageName, }: AsyncRuntimeHostContractInput): {\n    error?: string;\n    warning?: string;\n};\ntype CargoConfigFingerprint = readonly [path: string, hash: string];\nexport declare function getCargoDependencyGraphFingerprint(metadata: CargoWorkspaceMetadata, rootPackageId: string): string;\nexport declare function getTypeDefCacheFolder(options: {\n    targetDir: string;\n    crateName: string;\n    manifestPath: string;\n    targetTriple: string;\n    profile: string;\n    features?: string[];\n    allFeatures?: boolean;\n    noDefaultFeatures?: boolean;\n    cargoOptions?: string[];\n    rustFlags?: Record<string, string | undefined>;\n    cargoProfileEnv?: Record<string, string | undefined>;\n    cargoConfig?: CargoConfigFingerprint[];\n    cargoDependencyGraph?: string;\n}): string;\n/**\n * Name of the emnapi archive directory built against the wasi-sdk 34 ABI.\n * Only the threaded target has one: the signature change it carries lives in\n * the threads-only futex code.\n */\nexport declare const EMNAPI_WASI_SDK_34_LINK_DIR = \"wasm32-wasip1-threads-wasi-sdk-34\";\nexport interface EmnapiLinkDirSelection {\n    /** Directory name under `emnapi/lib` whose archives should be linked. */\n    linkDirName: string;\n    /** Detected wasi-sdk major version, `null` when no wasi-sdk is configured. */\n    wasiSdkMajor: number | null;\n    /** `true` when the toolchain needs the wasi-sdk 34 archives. */\n    needsWasiSdk34: boolean;\n}\n/**\n * Pick the emnapi archive directory for a WASI build.\n *\n * wasi-libc removed the unused `int op` parameter from\n * `__wasilibc_futex_wait_atomic_wait` / `__wasilibc_futex_wait_maybe_busy`,\n * and wasi-sdk 34 is the first release shipping the 3-argument signature.\n * Linking the legacy 4-argument archives against a wasi-sdk >= 34 sysroot\n * makes `wasm-ld` report `function signature mismatch` and emit an invalid\n * wasm module, so emnapi publishes a second archive set for the new ABI and\n * the directory has to be chosen by wasi-sdk version, not by target triple.\n *\n * Without `WASI_SDK_PATH`, cargo links through `rust-lld` against the\n * wasi-libc bundled with the Rust standard library, so that archive is\n * probed instead. Rust picked up wasi-sdk 34 in rust-lang/rust#161773, which\n * lands in 1.100, and a toolchain carrying it needs the new archives even\n * though no wasi-sdk is configured.\n *\n * The legacy directory stays the default whenever the ABI cannot be\n * determined, and older emnapi releases ship it alone.\n */\nexport declare function selectEmnapiLinkDir(emnapiLibDir: string, wasiTarget: string, hasThreads: boolean, wasiSdkPath: string | undefined, { cwd, rustWasiLibc, }?: {\n    cwd?: string;\n    rustWasiLibc?: string | null;\n}): EmnapiLinkDirSelection;\nexport declare function createWasiCompilerFlags(wasiSdkPath: string, wasiTarget: string, hasThreads: boolean, shellEscapedFlags?: boolean): {\n    compileFlags: string;\n    linkerFlags: string;\n};\nexport declare function createArtifactDestinationName(binaryName: string, target: Target, sourceName: string, platform: boolean): string;\nexport declare function selectWasiBrowserTarget(buildTarget: Target, configuredTargets: Target[], emittedTargets: Target[]): Target;\nexport declare function createWasiBrowserEntry(packageName: string, platformArchABI: string, idents: string[]): string;\nexport declare function createWasiDeferredBindingTypeDef(bindingModuleSpecifier: string, hasTypeDef: boolean, platformArchABI?: string): string;\nexport interface ResolvedWasmMemory {\n    /** `undefined` keeps each template's own default (4000, or 1024 for `./workerd`). */\n    initialMemory?: number;\n    /** `undefined` keeps the template default (65536). */\n    maximumMemory?: number;\n}\n/**\n * Resolve the `WebAssembly.Memory` descriptor the generated loaders embed, for\n * one WASI flavor.\n *\n * The threaded loaders share one `shared: true` memory with every wasi-threads\n * worker, so it is sized for the whole pool. The threadless loaders have a\n * single thread and a plain growable `ArrayBuffer`, so they only need to clear\n * the module's link-time floor (`-zstack-size` plus static data) and grow on\n * demand. `napi.wasm.threadlessInitialMemory` sizes the threadless loaders\n * without shrinking the threaded one; unset, it falls back to\n * `napi.wasm.initialMemory` and nothing changes.\n */\nexport declare function resolveWasmMemory(wasm: NapiConfig['wasm'], hasThreads: boolean): ResolvedWasmMemory;\n/**\n * Whether a build's declaration file should declare `__napiBindingTarget`.\n *\n * The export exists only on a generated loader, so the declaration has to\n * follow the loaders a build actually writes. This mirrors both writers:\n *\n * - {@link writeJsBinding} writes the root loader for `--platform` without\n *   `--no-js-binding` (`rootLoaderCandidate`), and then only when the build has\n *   runtime exports or a WASI flavor to fall back to.\n * - `Builder.writeWasiBinding` writes a flavor's loader set when that flavor is\n *   the build target, or when an earlier build of it left metadata on disk\n *   (`emitsWasiLoader`). A merely configured flavor is skipped, and a build\n *   that skips every flavor emits no loader to carry the export.\n *\n * The export list is only known once typegen has run, and typegen writes the\n * declaration file itself, so the decision comes back as a predicate over that\n * list instead of a flag taken up front.\n *\n * It gates the *reservation* of the name too — `Builder.generateTypeDef` calls\n * {@link assertBindingTargetIdentFree} only when this answers `true`. Declaring\n * the name and forbidding an addon from exporting it are the same question, and\n * a build that emits no loader asks neither.\n */\nexport declare function bindingTargetDeclarationPredicate(input: {\n    rootLoaderCandidate: boolean;\n    hasWasiFallback: boolean;\n    emitsWasiLoader: boolean;\n}): (exports: readonly string[]) => boolean;\nexport declare function prepareWasiBindingTypeDef(source: string, sourcePath: string, destinationPath: string, hasThreads: boolean, packageType?: 'module' | 'commonjs'): string;\n/**\n * Make a declaration file declare the `__napiBindingTarget` its loader exports.\n *\n * `platformArchABI` names the WASI flavor the file types, and the declaration\n * is then that flavor's exact literal; without it the file is the root entry's\n * and keeps the full union, which only the root entry can reach.\n *\n * Two kinds of file arrive here. A WASI declaration derived fresh from the root\n * `index.d.ts` inherits that union and has to be narrowed. A declaration kept\n * from an earlier build — a build that does not target WASI regenerates every\n * declared flavor's loader from the metadata that flavor's own build left\n * behind, and reuses its declaration file verbatim — may predate the export\n * entirely, or carry a union an earlier version of this branch wrote.\n *\n * Either may also carry a declaration nobody here wrote, because a project's\n * own `--dts-header` may declare the export to work around loaders that predate\n * it. So ownership, not mere presence, decides what happens.\n *\n * Three cases, decided in this order:\n *\n * - The declaration the rendered `.d.ts` header owns. `renderedHeader` is that\n *   header as this build rendered it; if it declares the export, the project's\n *   own declaration wins: nothing is appended, and it is never rewritten.\n *   Declaring it a second time would be a TS2451 redeclaration.\n *\n *   The header is matched by the text of its declaration against the first\n *   declaration in the file, not by a prefix of the file. A WASI declaration is\n *   derived through {@link prepareWasiBindingTypeDef}, which rewrites relative\n *   import specifiers and, for the threadless flavor, drops `node:stream/web`\n *   imports — a header carrying either stops being a literal prefix of the file\n *   derived from it, while the declaration statement itself comes through\n *   untouched and stays the first one, because those rewrites never reorder\n *   statements. On the preserved path the header in hand is this build's, not\n *   the one the kept file was written with, and a kept declaration that reads\n *   differently is correctly not the header's.\n * - A declaration the header does not own, alone in its statement, whose type\n *   is built only out of the literals this CLI writes\n *   ({@link isGeneratedBindingTargetType}), is one of ours. Stale — an older\n *   union, or the other flavor's literal — it is replaced in place, comment\n *   and all, so a file kept from an earlier build ends up saying what the\n *   loader written beside it now reports.\n * - Any other export of the name is someone else's and is preserved, with\n *   nothing appended beside it. A looser match would rewrite a declaration a\n *   `--dts-header` contributed. That covers a statement declaring more names\n *   than this one — the block a refresh replaces spans them too, and this CLI\n *   writes the declaration alone — and it covers every other way a header can\n *   claim the name: as a `function`, `class`, `enum` or instantiated\n *   `namespace`, through an `export { target as __napiBindingTarget }` or\n *   `export * as __napiBindingTarget from '…'` clause, or through\n *   `export import __napiBindingTarget = …`. None of those leaves a\n *   declaration here to rewrite, and an export added beside any of them is a\n *   TypeScript error (TS2300, TS2323, TS2440 or TS2567 by form).\n *\n *   A header that exports the name in type space only — a `type`, an\n *   `interface`, a namespace that declares no value — claims nothing: the\n *   declaration merges with it, and withholding it would cost a consumer the\n *   value the loader really exports — see {@link scanExportedName}.\n *\n * A declaration file that exports by assignment (`export = binding`, what a\n * build without `napi-derive`'s `type-def` feature emits) cannot carry a named\n * export declaration, so it is left alone; its exports are untyped anyway.\n * That, too, is read off the parse — a block comment documenting the CommonJS\n * form is not an export assignment.\n */\nexport declare function ensureBindingTargetDeclaration(typeDef: string, platformArchABI?: string, renderedHeader?: string): string;\nexport declare function collectStaleWasiBuildOutputNames(binaryName: string, buildTarget: Target, configuredTargets: Target[]): Set<string>;\nexport declare function removeWasmCustomSection(binary: Uint8Array, sectionName: string): Uint8Array;\ntype BuildFormatOptions = {\n    format?: string;\n    esm?: boolean;\n    commonjs?: boolean;\n};\n/**\n * Resolve the explicit build format and its legacy CLI/API aliases.\n *\n * CommonJS is the historical default. The aliases are intentionally kept\n * separate from `format` because `--esm` and `--commonjs` are boolean flags,\n * while `--format` takes a value.\n */\nexport declare function resolveBuildFormat(options: BuildFormatOptions): BuildFormat;\n/** Build the configured NAPI-RS crate and generate its output artifacts. */\nexport declare function buildProject(rawOptions: BuildOptions): Promise<{\n    task: Promise<Output[]>;\n    abort: () => void;\n}>;\n/**\n * Validate the combination of the cross-compilation related flags.\n *\n * `--use-cross`, `--use-napi-cross` and `--cross-compile` (`-x`) are three\n * mutually exclusive cross-compilation mechanisms; combining any two of them\n * leaves both active at once and produces broken builds, so it is rejected\n * upfront before any side effect (like auto-installing cargo binaries or\n * downloading toolchains) happens.\n *\n * `--cross-compile` with a `windows-gnu` target is rejected as well: on a\n * non-Windows host it routes the build to `cargo xwin build`, but\n * `cargo-xwin` only sets up MSVC toolchains — for `windows-gnu` targets it\n * silently does nothing and the build dies much later with a cryptic\n * ``error: linker `x86_64-w64-mingw32-gcc` not found`` that never mentions\n * `cargo-xwin`. Only an explicitly requested target (`--target` or\n * `CARGO_BUILD_TARGET`) is inspected, so this validation never has to spawn\n * `rustc -vV`; a non-Windows host's default target can never be\n * `windows-gnu` anyway.\n */\nexport declare function validateCrossCompileFlags(options: {\n    useCross?: boolean;\n    crossCompile?: boolean;\n    useNapiCross?: boolean;\n    watch?: boolean;\n    target?: string;\n}, hostPlatform?: string): void;\n/**\n * Validate that `--use-napi-cross` can actually handle the requested target\n * on the current host. The supported target set is read from the\n * `@napi-rs/cross-toolchain` package, and the pre-built toolchains only run\n * on Linux x64 and Linux arm64 hosts.\n */\nexport declare function validateNapiCrossSupport(targetTriple: string, hostPlatform?: string, hostArch?: string): void;\n/**\n * Compute the environment variables that route a `--use-napi-cross` build\n * through the `@napi-rs/cross-toolchain` toolchain extracted at\n * `toolchainPath`.\n *\n * Follows the same rule as `Builder#setEnvIfNotExists`: a variable the user\n * already set in `env` wins and is not returned, and a present-but-empty\n * variable counts as unset (falsy semantics). The only exceptions are the\n * clang-specific `TARGET_CFLAGS`/`TARGET_CXXFLAGS`, which prepend the sysroot\n * flags to the user's value, and `PATH`, which always gets the toolchain\n * `bin` directory prepended.\n *\n * Exported for tests.\n */\nexport declare function napiCrossToolchainEnvs(toolchainPath: string, targetTriple: string, env?: NodeJS.ProcessEnv): Record<string, string>;\nexport declare function verifyWasiReactor(wasmPath: string): Promise<void>;\nexport interface WriteJsBindingOptions {\n    platform?: boolean;\n    noJsBinding?: boolean;\n    idents: string[];\n    jsBinding?: string;\n    format?: BuildFormat;\n    esm?: boolean;\n    commonjs?: boolean;\n    binaryName: string;\n    packageName: string;\n    version: string;\n    outputDir: string;\n    /**\n     * `platformArchABI`s of the declared WASI targets in fallback preference\n     * order (threaded first). Defaults to the legacy `['wasm32-wasi']` chain\n     * when omitted or empty. Generated loaders expose these exact identities\n     * through `NAPI_RS_WASI_FLAVOR`.\n     */\n    wasiFlavors?: string[];\n}\n/** Write a platform binding loader in the requested module format. */\nexport declare function writeJsBinding(options: WriteJsBindingOptions): Promise<Output | undefined>;\nexport interface GenerateTypeDefOptions {\n    typeDefDir: string;\n    noDtsHeader?: boolean;\n    dtsHeader?: string;\n    dtsHeaderFile?: string;\n    configDtsHeader?: string;\n    configDtsHeaderFile?: string;\n    constEnum?: boolean;\n    runtimeStringEnum?: boolean;\n    cwd: string;\n    /**\n     * Declare the generated loader's `__napiBindingTarget` export. Set it for\n     * builds that emit a loader; a build that emits none declares nothing. The\n     * declared union covers every artifact a loader can hand back, not only the\n     * targets this package builds — see {@link BINDING_TARGET_TYPE_UNION}.\n     *\n     * Whether the root loader is written depends on the exports this build\n     * produced, which only typegen knows, so a predicate may be passed instead\n     * of a flag; it is called with the generated export list. See\n     * {@link bindingTargetDeclarationPredicate}.\n     */\n    declareBindingTarget?: boolean | ((exports: readonly string[]) => boolean);\n}\n/**\n * Walk the napi-derive intermediate type-def directory, render every entry\n * into TypeScript via {@link processTypeDef}, and return the concatenated\n * `.d.ts` source plus the list of identifiers to re-export from\n * `index.js`.\n */\nexport declare function generateTypeDef(options: GenerateTypeDefOptions): Promise<{\n    exports: string[];\n    dts: string;\n    dtsWithTypeImports: string;\n    /**\n     * The `.d.ts` header as rendered, before anything the generated body needs\n     * was appended to it. `ensureBindingTargetDeclaration` takes it to tell a\n     * declaration the header owns from one this build wrote.\n     */\n    header: string;\n}>;\nexport {};\n","import { Command } from 'clipanion';\nexport declare abstract class BaseCreateNpmDirsCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    dryRun: boolean;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        npmDir: string;\n        dryRun: boolean;\n    };\n}\n/**\n * Create npm package dirs for different platforms\n */\nexport interface CreateNpmDirsOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n    /**\n     * Dry run without touching file system\n     *\n     * @default false\n     */\n    dryRun?: boolean;\n}\nexport declare function applyDefaultCreateNpmDirsOptions(options: CreateNpmDirsOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    dryRun: boolean;\n};\n","import { type CreateNpmDirsOptions } from '../def/create-npm-dirs.js';\nexport interface PackageMeta {\n    'dist-tags': {\n        [index: string]: string;\n    };\n}\nexport declare function createNpmDirs(userOptions: CreateNpmDirsOptions): Promise<void>;\n","import { Command } from 'clipanion';\nexport declare abstract class BaseNewCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    $$path: string | undefined;\n    $$name?: string;\n    minNodeApiVersion: number;\n    packageManager: string;\n    license: string;\n    targets: string[];\n    enableDefaultTargets: boolean;\n    enableAllTargets: boolean;\n    enableTypeDef: boolean;\n    enableGithubActions: boolean;\n    testFramework: string;\n    dryRun: boolean;\n    getOptions(): {\n        path: string | undefined;\n        name: string | undefined;\n        minNodeApiVersion: number;\n        packageManager: string;\n        license: string;\n        targets: string[];\n        enableDefaultTargets: boolean;\n        enableAllTargets: boolean;\n        enableTypeDef: boolean;\n        enableGithubActions: boolean;\n        testFramework: string;\n        dryRun: boolean;\n    };\n}\n/**\n * Create a new project with pre-configured boilerplate\n */\nexport interface NewOptions {\n    /**\n     * The path where the NAPI-RS project will be created.\n     */\n    path?: string;\n    /**\n     * The name of the project, default to the name of the directory if not provided\n     */\n    name?: string;\n    /**\n     * The minimum Node-API version to support\n     *\n     * @default 4\n     */\n    minNodeApiVersion?: number;\n    /**\n     * The package manager to use. Only support yarn 4.x for now.\n     *\n     * @default 'yarn'\n     */\n    packageManager?: string;\n    /**\n     * License for open-sourced project\n     *\n     * @default 'MIT'\n     */\n    license?: string;\n    /**\n     * All targets the crate will be compiled for.\n     *\n     * @default []\n     */\n    targets?: string[];\n    /**\n     * Whether enable default targets\n     *\n     * @default true\n     */\n    enableDefaultTargets?: boolean;\n    /**\n     * Whether enable all targets\n     *\n     * @default false\n     */\n    enableAllTargets?: boolean;\n    /**\n     * Whether enable the `type-def` feature for typescript definitions auto-generation\n     *\n     * @default true\n     */\n    enableTypeDef?: boolean;\n    /**\n     * Whether generate preconfigured GitHub Actions workflow\n     *\n     * @default true\n     */\n    enableGithubActions?: boolean;\n    /**\n     * The JavaScript test framework to use, only support `ava` for now\n     *\n     * @default 'ava'\n     */\n    testFramework?: string;\n    /**\n     * Whether to run the command in dry-run mode\n     *\n     * @default false\n     */\n    dryRun?: boolean;\n}\nexport declare function applyDefaultNewOptions(options: NewOptions): {\n    /**\n     * The path where the NAPI-RS project will be created.\n     */\n    path?: string;\n    /**\n     * The name of the project, default to the name of the directory if not provided\n     */\n    name?: string;\n    minNodeApiVersion: number;\n    packageManager: string;\n    license: string;\n    targets: string[];\n    enableDefaultTargets: boolean;\n    enableAllTargets: boolean;\n    enableTypeDef: boolean;\n    enableGithubActions: boolean;\n    testFramework: string;\n    dryRun: boolean;\n};\n","import { type NewOptions as RawNewOptions } from '../def/new.js';\ntype NewOptions = Required<RawNewOptions>;\nexport declare const GENERATED_WASI_BINDING: RegExp;\nexport declare function updateCargoTomlNodeApiVersion(filePath: string, minNodeApiVersion: number): Promise<void>;\nexport declare function newProject(userOptions: RawNewOptions): Promise<void>;\nexport type { NewOptions };\n","import { Command } from 'clipanion';\nexport declare abstract class BasePrePublishCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    tagStyle: string;\n    ghRelease: boolean;\n    ghReleaseName?: string;\n    ghReleaseId?: string;\n    skipOptionalPublish: boolean;\n    rootPublisher?: 'npm' | 'pnpm' | 'yarn' | 'yarn-classic';\n    dryRun: boolean;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        npmDir: string;\n        tagStyle: string;\n        ghRelease: boolean;\n        ghReleaseName: string | undefined;\n        ghReleaseId: string | undefined;\n        skipOptionalPublish: boolean;\n        rootPublisher: \"yarn\" | \"pnpm\" | \"npm\" | \"yarn-classic\" | undefined;\n        dryRun: boolean;\n    };\n}\n/**\n * Update package.json and copy addons into per platform packages\n */\nexport interface PrePublishOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n    /**\n     * git tag style, `npm` or `lerna`\n     *\n     * @default 'lerna'\n     */\n    tagStyle?: 'npm' | 'lerna';\n    /**\n     * Whether create GitHub release\n     *\n     * @default true\n     */\n    ghRelease?: boolean;\n    /**\n     * GitHub release name\n     */\n    ghReleaseName?: string;\n    /**\n     * Existing GitHub release id\n     */\n    ghReleaseId?: string;\n    /**\n     * Whether skip optionalDependencies packages publish\n     *\n     * @default false\n     */\n    skipOptionalPublish?: boolean;\n    /**\n     * The package manager that publishes the root package. pnpm and yarn berry replace `exports` with `publishConfig.exports` while packing, so for them the root package validation targets the publish-effective export map. Defaults to the `napi.rootPublisher` config field, and validates both export maps when neither is set\n     */\n    rootPublisher?: 'npm' | 'pnpm' | 'yarn' | 'yarn-classic';\n    /**\n     * Dry run without touching file system\n     *\n     * @default false\n     */\n    dryRun?: boolean;\n}\nexport declare function applyDefaultPrePublishOptions(options: PrePublishOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    tagStyle: string;\n    ghRelease: boolean;\n    /**\n     * GitHub release name\n     */\n    ghReleaseName?: string;\n    /**\n     * Existing GitHub release id\n     */\n    ghReleaseId?: string;\n    skipOptionalPublish: boolean;\n    /**\n     * The package manager that publishes the root package. pnpm and yarn berry replace `exports` with `publishConfig.exports` while packing, so for them the root package validation targets the publish-effective export map. Defaults to the `napi.rootPublisher` config field, and validates both export maps when neither is set\n     */\n    rootPublisher?: \"npm\" | \"pnpm\" | \"yarn\" | \"yarn-classic\";\n    dryRun: boolean;\n};\n","import { type PrePublishOptions } from '../def/pre-publish.js';\nimport { type CommonPackageJsonFields, type RootPublisher, type Target, type UserNapiConfig } from '../utils/index.js';\n/**\n * Build the root package's `optionalDependencies` map.\n *\n * A WASI package is a fallback for hosts that cannot load a `.node` binary, and\n * the generated binding loader selects it at require time rather than npm\n * selecting it at install time. Declaring it as an `optionalDependency`\n * alongside the native packages cannot express \"install this only when nothing\n * else matched\": npm evaluates every entry independently, so every consumer\n * downloads a `.wasm` binary they will never load.\n *\n * It is therefore only declared when WASI is the only configured target, which\n * makes it the primary artifact rather than a fallback.\n * `napi.wasm.optionalDependency` overrides the default in both directions.\n *\n * See https://github.com/rolldown/rolldown/issues/10556\n */\nexport declare function resolveRootOptionalDependencies({ existing, managedPackageNames, packageName, targets, version, wasm, }: {\n    existing: unknown;\n    managedPackageNames: Iterable<string>;\n    packageName: string;\n    targets: Target[];\n    version: string;\n    wasm?: UserNapiConfig['wasm'];\n}): Record<string, unknown>;\nexport declare function prePublish(userOptions: PrePublishOptions): Promise<void>;\ninterface ThreadlessWasiRootFacade {\n    exports: Record<string, unknown>;\n    publishConfigExports?: Record<string, unknown>;\n    generatedFiles: string[];\n    files: ThreadlessWasiRootFacadeFiles;\n    wasmSourcePath: string;\n    marker: string;\n    forwardingModule: string;\n    packageJsonUpdate: {\n        files?: string[];\n    };\n}\ninterface ThreadlessWasiRootFacadeFiles {\n    workerdEntry: string;\n    workerdTypeDef: string;\n    wasmEntry: string;\n    wasmTypeDef: string;\n}\nexport declare function rootPublisherRewritesRootExports(rootPublisher: RootPublisher | undefined): boolean;\nexport declare function resolveRootPublisher(optionValue: string | undefined, configValue: string | undefined): RootPublisher | undefined;\nexport declare function sniffRewritingPublisherFromUserAgent(userAgent?: string | undefined): 'pnpm' | 'yarn' | undefined;\nexport declare function rootPublisherHint(rootPublisher: RootPublisher | undefined, userAgent?: string): string;\nexport declare function collectRootPackagePathReferences(packageJson: CommonPackageJsonFields, rootPublisher?: RootPublisher): string[];\nexport declare function parseNpmPackFiles(output: string): Set<string>;\nexport declare function validateRootFacadePacklist(rootDir: string, rootPackageFiles: string[], rootPublisher?: RootPublisher): void;\ninterface RootReleaseMaterializationPlan {\n    packageJson: CommonPackageJsonFields;\n    optionalDependencies: Record<string, unknown>;\n    nodeEngine?: string;\n    facade?: ThreadlessWasiRootFacade;\n    staleGeneratedFiles: string[];\n    rootPublisher?: RootPublisher;\n}\ninterface ReleasePackageValidationOptions {\n    pkgDir: string;\n    rootDir: string;\n    packageName: string;\n    binaryName: string;\n    target: Target;\n    requireDirectBufferDependency: boolean;\n}\ninterface ReleasePackageMaterializationPlan {\n    target: Target;\n    pkgDir: string;\n    rootDir: string;\n    stagedPkgDir?: string;\n    packageFiles: string[];\n    declarationDependencies: string[];\n    updateManifest: boolean;\n}\ninterface CommitPrePublishFileSystemTransactionOptions {\n    packageJsonPath: string;\n    releasePackagePlans: ReleasePackageMaterializationPlan[];\n    rootDir: string;\n    rootReleasePlan: RootReleaseMaterializationPlan;\n    stagedRootManifestPath?: string;\n    stagedRootDir: string;\n    transactionRoot?: string;\n}\nexport declare function commitPrePublishFileSystemTransaction({ packageJsonPath, releasePackagePlans, rootDir, rootReleasePlan, stagedRootDir, stagedRootManifestPath, transactionRoot, }: CommitPrePublishFileSystemTransactionOptions): Promise<void>;\nexport declare function validateReleasePackageContents({ pkgDir, rootDir, packageName, binaryName, target, requireDirectBufferDependency, }: ReleasePackageValidationOptions): Promise<{\n    packageFiles: string[];\n    declarationDependencies: string[];\n    updateManifest: boolean;\n}>;\nexport {};\n","import { Command } from 'clipanion';\nexport declare abstract class BaseRenameCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    $$name?: string;\n    binaryName?: string;\n    packageName?: string;\n    manifestPath: string;\n    repository?: string;\n    description?: string;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        npmDir: string;\n        name: string | undefined;\n        binaryName: string | undefined;\n        packageName: string | undefined;\n        manifestPath: string;\n        repository: string | undefined;\n        description: string | undefined;\n    };\n}\n/**\n * Rename the NAPI-RS project\n */\nexport interface RenameOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n    /**\n     * The new name of the project\n     */\n    name?: string;\n    /**\n     * The new binary name *.node files\n     */\n    binaryName?: string;\n    /**\n     * The new package name of the project\n     */\n    packageName?: string;\n    /**\n     * Path to `Cargo.toml`\n     *\n     * @default 'Cargo.toml'\n     */\n    manifestPath?: string;\n    /**\n     * The new repository of the project\n     */\n    repository?: string;\n    /**\n     * The new description of the project\n     */\n    description?: string;\n}\nexport declare function applyDefaultRenameOptions(options: RenameOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    /**\n     * The new name of the project\n     */\n    name?: string;\n    /**\n     * The new binary name *.node files\n     */\n    binaryName?: string;\n    /**\n     * The new package name of the project\n     */\n    packageName?: string;\n    manifestPath: string;\n    /**\n     * The new repository of the project\n     */\n    repository?: string;\n    /**\n     * The new description of the project\n     */\n    description?: string;\n};\n","import { type RenameOptions } from '../def/rename.js';\nexport declare function renameProject(userOptions: RenameOptions): Promise<void>;\n","import { Command } from 'clipanion';\nexport declare abstract class BaseUniversalizeCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    outputDir: string;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        outputDir: string;\n    };\n}\n/**\n * Combile built binaries into one universal binary\n */\nexport interface UniversalizeOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where all built `.node` files put, same as `--output-dir` of build command\n     *\n     * @default './'\n     */\n    outputDir?: string;\n}\nexport declare function applyDefaultUniversalizeOptions(options: UniversalizeOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    outputDir: string;\n};\n","import { type UniversalizeOptions } from '../def/universalize.js';\nexport declare function universalizeBinaries(userOptions: UniversalizeOptions): Promise<void>;\n","import { Command } from 'clipanion';\nexport declare abstract class BaseVersionCommand extends Command {\n    static paths: string[][];\n    static usage: import(\"clipanion\").Usage;\n    cwd: string;\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n    getOptions(): {\n        cwd: string;\n        configPath: string | undefined;\n        packageJsonPath: string;\n        npmDir: string;\n    };\n}\n/**\n * Update version in created npm packages\n */\nexport interface VersionOptions {\n    /**\n     * The working directory of where napi command will be executed in, all other paths options are relative to this path\n     *\n     * @default process.cwd()\n     */\n    cwd?: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    /**\n     * Path to `package.json`\n     *\n     * @default 'package.json'\n     */\n    packageJsonPath?: string;\n    /**\n     * Path to the folder where the npm packages put\n     *\n     * @default 'npm'\n     */\n    npmDir?: string;\n}\nexport declare function applyDefaultVersionOptions(options: VersionOptions): {\n    cwd: string;\n    /**\n     * Path to `napi` config json file\n     */\n    configPath?: string;\n    packageJsonPath: string;\n    npmDir: string;\n};\n","import { type VersionOptions } from '../def/version.js';\nexport declare function version(userOptions: VersionOptions): Promise<void>;\n","import { BaseArtifactsCommand } from '../def/artifacts.js';\nexport declare class ArtifactsCommand extends BaseArtifactsCommand {\n    static usage: import(\"clipanion\").Usage;\n    static paths: string[][];\n    execute(): Promise<void>;\n}\n","import { BaseBuildCommand } from '../def/build.js';\nexport declare class BuildCommand extends BaseBuildCommand {\n    pipe: string | undefined;\n    cargoOptions: string[];\n    execute(): Promise<void>;\n}\n","import { BaseCreateNpmDirsCommand } from '../def/create-npm-dirs.js';\nexport declare class CreateNpmDirsCommand extends BaseCreateNpmDirsCommand {\n    execute(): Promise<void>;\n}\n","import { BaseNewCommand } from '../def/new.js';\nexport declare function getNapiVersionChoices(): {\n    name: string;\n    value: import(\"../utils/version.js\").NapiVersion;\n}[];\nexport declare class NewCommand extends BaseNewCommand {\n    interactive: boolean;\n    execute(): Promise<0 | 1>;\n    private fetchOptions;\n    private fetchName;\n    private fetchLicense;\n    private fetchNapiVersion;\n    private fetchTargets;\n    private fetchTypeDef;\n    private fetchGithubActions;\n}\n","import { BasePrePublishCommand } from '../def/pre-publish.js';\nexport declare class PrePublishCommand extends BasePrePublishCommand {\n    execute(): Promise<void>;\n}\n","import { BaseRenameCommand } from '../def/rename.js';\nexport declare class RenameCommand extends BaseRenameCommand {\n    execute(): Promise<void>;\n}\n","import { BaseUniversalizeCommand } from '../def/universalize.js';\nexport declare class UniversalizeCommand extends BaseUniversalizeCommand {\n    execute(): Promise<void>;\n}\n","import { BaseVersionCommand } from '../def/version.js';\nexport declare class VersionCommand extends BaseVersionCommand {\n    execute(): Promise<void>;\n}\n","import { Cli } from 'clipanion';\nimport { collectArtifacts } from './api/artifacts.js';\nimport { buildProject } from './api/build.js';\nimport { createNpmDirs } from './api/create-npm-dirs.js';\nimport { newProject } from './api/new.js';\nimport { prePublish } from './api/pre-publish.js';\nimport { renameProject } from './api/rename.js';\nimport { universalizeBinaries } from './api/universalize.js';\nimport { version } from './api/version.js';\nimport { ArtifactsCommand } from './commands/artifacts.js';\nimport { BuildCommand } from './commands/build.js';\nimport { CreateNpmDirsCommand } from './commands/create-npm-dirs.js';\nimport { NewCommand } from './commands/new.js';\nimport { PrePublishCommand } from './commands/pre-publish.js';\nimport { RenameCommand } from './commands/rename.js';\nimport { UniversalizeCommand } from './commands/universalize.js';\nimport { VersionCommand } from './commands/version.js';\nexport declare const cli: Cli<import(\"clipanion\").BaseContext>;\n/**\n *\n * @usage\n *\n * ```ts\n * const cli = new NapiCli()\n *\n * cli.build({\n *   cwd: '/path/to/your/project',\n * })\n * ```\n */\nexport declare class NapiCli {\n    artifacts: typeof collectArtifacts;\n    new: typeof newProject;\n    build: typeof buildProject;\n    createNpmDirs: typeof createNpmDirs;\n    prePublish: typeof prePublish;\n    rename: typeof renameProject;\n    universalize: typeof universalizeBinaries;\n    version: typeof version;\n}\nexport declare function createBuildCommand(args: string[]): BuildCommand;\nexport declare function createArtifactsCommand(args: string[]): ArtifactsCommand;\nexport declare function createCreateNpmDirsCommand(args: string[]): CreateNpmDirsCommand;\nexport declare function createPrePublishCommand(args: string[]): PrePublishCommand;\nexport declare function createRenameCommand(args: string[]): RenameCommand;\nexport declare function createUniversalizeCommand(args: string[]): UniversalizeCommand;\nexport declare function createVersionCommand(args: string[]): VersionCommand;\nexport declare function createNewCommand(args: string[]): NewCommand;\nexport { parseTriple } from './utils/target.js';\nexport { type GenerateTypeDefOptions, type WriteJsBindingOptions, writeJsBinding, generateTypeDef, } from './api/build.js';\nexport { readNapiConfig } from './utils/config.js';\n"],"mappings":"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"}