import * as _$clipanion from "clipanion";
import { Cli, Command } from "clipanion";

//#region src/def/artifacts.d.ts
declare abstract class BaseArtifactsCommand extends Command {
  static paths: string[][];
  static usage: _$clipanion.Usage;
  cwd: string;
  configPath?: string;
  packageJsonPath: string;
  outputDir: string;
  npmDir: string;
  buildOutputDir?: string;
  getOptions(): {
    cwd: string;
    configPath: string | undefined;
    packageJsonPath: string;
    outputDir: string;
    npmDir: string;
    buildOutputDir: string | undefined;
  };
}
/**
 * Copy artifacts from Github Actions into npm packages and ready to publish
 */
interface ArtifactsOptions {
  /**
   * The working directory of where napi command will be executed in, all other paths options are relative to this path
   *
   * @default process.cwd()
   */
  cwd?: string;
  /**
   * Path to `napi` config json file
   */
  configPath?: string;
  /**
   * Path to `package.json`
   *
   * @default 'package.json'
   */
  packageJsonPath?: string;
  /**
   * Path to the folder where all built `.node` files put, same as `--output-dir` of build command
   *
   * @default './artifacts'
   */
  outputDir?: string;
  /**
   * Path to the folder where the npm packages put
   *
   * @default 'npm'
   */
  npmDir?: string;
  /**
   * Path to the build output dir, only needed when targets contains `wasm32-wasi-*`
   */
  buildOutputDir?: string;
}
//#endregion
//#region src/api/artifacts.d.ts
declare function collectArtifacts(userOptions: ArtifactsOptions): Promise<void>;
//#endregion
//#region src/def/build.d.ts
declare abstract class BaseBuildCommand extends Command {
  static paths: string[][];
  static usage: _$clipanion.Usage;
  target?: string;
  cwd?: string;
  manifestPath?: string;
  configPath?: string;
  packageJsonPath?: string;
  targetDir?: string;
  outputDir?: string;
  platform?: boolean;
  jsPackageName?: string;
  constEnum?: boolean;
  runtimeStringEnum?: boolean;
  jsBinding?: string;
  noJsBinding?: boolean;
  dts?: string;
  dtsHeader?: string;
  noDtsHeader?: boolean;
  dtsCache: boolean;
  esm?: boolean;
  strip?: boolean;
  release?: boolean;
  verbose?: boolean;
  bin?: string;
  package?: string;
  profile?: string;
  crossCompile?: boolean;
  useCross?: boolean;
  useNapiCross?: boolean;
  watch?: boolean;
  features?: string[];
  allFeatures?: boolean;
  noDefaultFeatures?: boolean;
  getOptions(): {
    target: string | undefined;
    cwd: string | undefined;
    manifestPath: string | undefined;
    configPath: string | undefined;
    packageJsonPath: string | undefined;
    targetDir: string | undefined;
    outputDir: string | undefined;
    platform: boolean | undefined;
    jsPackageName: string | undefined;
    constEnum: boolean | undefined;
    runtimeStringEnum: boolean | undefined;
    jsBinding: string | undefined;
    noJsBinding: boolean | undefined;
    dts: string | undefined;
    dtsHeader: string | undefined;
    noDtsHeader: boolean | undefined;
    dtsCache: boolean;
    esm: boolean | undefined;
    strip: boolean | undefined;
    release: boolean | undefined;
    verbose: boolean | undefined;
    bin: string | undefined;
    package: string | undefined;
    profile: string | undefined;
    crossCompile: boolean | undefined;
    useCross: boolean | undefined;
    useNapiCross: boolean | undefined;
    watch: boolean | undefined;
    features: string[] | undefined;
    allFeatures: boolean | undefined;
    noDefaultFeatures: boolean | undefined;
  };
}
/**
 * Build the NAPI-RS project
 */
interface BuildOptions$1 {
  /**
   * Build for the target triple, bypassed to `cargo build --target`
   */
  target?: string;
  /**
   * The working directory of where napi command will be executed in, all other paths options are relative to this path
   */
  cwd?: string;
  /**
   * Path to `Cargo.toml`
   */
  manifestPath?: string;
  /**
   * Path to `napi` config json file
   */
  configPath?: string;
  /**
   * Path to `package.json`
   */
  packageJsonPath?: string;
  /**
   * Directory for all crate generated artifacts, see `cargo build --target-dir`
   */
  targetDir?: string;
  /**
   * Path to where all the built files would be put. Default to the crate folder
   */
  outputDir?: string;
  /**
   * Add platform triple to the generated nodejs binding file, eg: `[name].linux-x64-gnu.node`
   */
  platform?: boolean;
  /**
   * Package name in generated js binding file. Only works with `--platform` flag
   */
  jsPackageName?: string;
  /**
   * Whether generate const enum for typescript bindings
   */
  constEnum?: boolean;
  /**
   * Emit `#[napi(string_enum)]` enums as runtime enums (`export declare enum`) under `--no-const-enum`. Default: type-only union.
   */
  runtimeStringEnum?: boolean;
  /**
   * Path and filename of generated JS binding file. Only works with `--platform` flag. Relative to `--output-dir`.
   */
  jsBinding?: string;
  /**
   * Whether to disable the generation JS binding file. Only works with `--platform` flag.
   */
  noJsBinding?: boolean;
  /**
   * Path and filename of generated type def file. Relative to `--output-dir`
   */
  dts?: string;
  /**
   * Custom file header for generated type def file. Only works when `typedef` feature enabled.
   */
  dtsHeader?: string;
  /**
   * Whether to disable the default file header for generated type def file. Only works when `typedef` feature enabled.
   */
  noDtsHeader?: boolean;
  /**
   * Whether to enable the dts cache, default to true
   *
   * @default true
   */
  dtsCache?: boolean;
  /**
   * Whether to emit an ESM JS binding file instead of CJS format. Only works with `--platform` flag.
   */
  esm?: boolean;
  /**
   * Whether strip the library to achieve the minimum file size
   */
  strip?: boolean;
  /**
   * Build in release mode
   */
  release?: boolean;
  /**
   * Verbosely log build command trace
   */
  verbose?: boolean;
  /**
   * Build only the specified binary
   */
  bin?: string;
  /**
   * Build the specified library or the one at cwd
   */
  package?: string;
  /**
   * Build artifacts with the specified profile
   */
  profile?: string;
  /**
   * [experimental] cross-compile for the specified target with `cargo-xwin` on windows and `cargo-zigbuild` on other platform
   */
  crossCompile?: boolean;
  /**
   * [experimental] use [cross](https://github.com/cross-rs/cross) instead of `cargo`
   */
  useCross?: boolean;
  /**
   * [experimental] use @napi-rs/cross-toolchain to cross-compile Linux arm/arm64/x64 gnu targets.
   */
  useNapiCross?: boolean;
  /**
   * watch the crate changes and build continuously with `cargo-watch` crates
   */
  watch?: boolean;
  /**
   * Space-separated list of features to activate
   */
  features?: string[];
  /**
   * Activate all available features
   */
  allFeatures?: boolean;
  /**
   * Do not activate the `default` feature
   */
  noDefaultFeatures?: boolean;
}
//#endregion
//#region src/api/build.d.ts
type OutputKind = 'js' | 'dts' | 'node' | 'exe' | 'wasm';
type Output = {
  kind: OutputKind;
  path: string;
};
type BuildOptions = BuildOptions$1 & {
  cargoOptions?: string[];
};
declare function buildProject(rawOptions: BuildOptions): Promise<{
  task: Promise<Output[]>;
  abort: () => void;
}>;
interface WriteJsBindingOptions {
  platform?: boolean;
  noJsBinding?: boolean;
  idents: string[];
  jsBinding?: string;
  esm?: boolean;
  binaryName: string;
  packageName: string;
  version: string;
  outputDir: string;
}
declare function writeJsBinding(options: WriteJsBindingOptions): Promise<Output | undefined>;
interface GenerateTypeDefOptions {
  typeDefDir: string;
  noDtsHeader?: boolean;
  dtsHeader?: string;
  dtsHeaderFile?: string;
  configDtsHeader?: string;
  configDtsHeaderFile?: string;
  constEnum?: boolean;
  runtimeStringEnum?: boolean;
  cwd: string;
}
/**
 * Walk the napi-derive intermediate type-def directory, render every entry
 * into TypeScript via {@link processTypeDef}, and return the concatenated
 * `.d.ts` source plus the list of identifiers to re-export from
 * `index.js`.
 */
declare function generateTypeDef(options: GenerateTypeDefOptions): Promise<{
  exports: string[];
  dts: string;
}>;
//#endregion
//#region src/def/create-npm-dirs.d.ts
declare abstract class BaseCreateNpmDirsCommand extends Command {
  static paths: string[][];
  static usage: _$clipanion.Usage;
  cwd: string;
  configPath?: string;
  packageJsonPath: string;
  npmDir: string;
  dryRun: boolean;
  getOptions(): {
    cwd: string;
    configPath: string | undefined;
    packageJsonPath: string;
    npmDir: string;
    dryRun: boolean;
  };
}
/**
 * Create npm package dirs for different platforms
 */
interface CreateNpmDirsOptions {
  /**
   * The working directory of where napi command will be executed in, all other paths options are relative to this path
   *
   * @default process.cwd()
   */
  cwd?: string;
  /**
   * Path to `napi` config json file
   */
  configPath?: string;
  /**
   * Path to `package.json`
   *
   * @default 'package.json'
   */
  packageJsonPath?: string;
  /**
   * Path to the folder where the npm packages put
   *
   * @default 'npm'
   */
  npmDir?: string;
  /**
   * Dry run without touching file system
   *
   * @default false
   */
  dryRun?: boolean;
}
//#endregion
//#region src/api/create-npm-dirs.d.ts
declare function createNpmDirs(userOptions: CreateNpmDirsOptions): Promise<void>;
//#endregion
//#region src/def/new.d.ts
declare abstract class BaseNewCommand extends Command {
  static paths: string[][];
  static usage: _$clipanion.Usage;
  $$path: string | undefined;
  $$name?: string;
  minNodeApiVersion: number;
  packageManager: string;
  license: string;
  targets: string[];
  enableDefaultTargets: boolean;
  enableAllTargets: boolean;
  enableTypeDef: boolean;
  enableGithubActions: boolean;
  testFramework: string;
  dryRun: boolean;
  getOptions(): {
    path: string | undefined;
    name: string | undefined;
    minNodeApiVersion: number;
    packageManager: string;
    license: string;
    targets: string[];
    enableDefaultTargets: boolean;
    enableAllTargets: boolean;
    enableTypeDef: boolean;
    enableGithubActions: boolean;
    testFramework: string;
    dryRun: boolean;
  };
}
/**
 * Create a new project with pre-configured boilerplate
 */
interface NewOptions {
  /**
   * The path where the NAPI-RS project will be created.
   */
  path?: string;
  /**
   * The name of the project, default to the name of the directory if not provided
   */
  name?: string;
  /**
   * The minimum Node-API version to support
   *
   * @default 4
   */
  minNodeApiVersion?: number;
  /**
   * The package manager to use. Only support yarn 4.x for now.
   *
   * @default 'yarn'
   */
  packageManager?: string;
  /**
   * License for open-sourced project
   *
   * @default 'MIT'
   */
  license?: string;
  /**
   * All targets the crate will be compiled for.
   *
   * @default []
   */
  targets?: string[];
  /**
   * Whether enable default targets
   *
   * @default true
   */
  enableDefaultTargets?: boolean;
  /**
   * Whether enable all targets
   *
   * @default false
   */
  enableAllTargets?: boolean;
  /**
   * Whether enable the `type-def` feature for typescript definitions auto-generation
   *
   * @default true
   */
  enableTypeDef?: boolean;
  /**
   * Whether generate preconfigured GitHub Actions workflow
   *
   * @default true
   */
  enableGithubActions?: boolean;
  /**
   * The JavaScript test framework to use, only support `ava` for now
   *
   * @default 'ava'
   */
  testFramework?: string;
  /**
   * Whether to run the command in dry-run mode
   *
   * @default false
   */
  dryRun?: boolean;
}
//#endregion
//#region src/api/new.d.ts
declare function newProject(userOptions: NewOptions): Promise<void>;
//#endregion
//#region src/def/pre-publish.d.ts
declare abstract class BasePrePublishCommand extends Command {
  static paths: string[][];
  static usage: _$clipanion.Usage;
  cwd: string;
  configPath?: string;
  packageJsonPath: string;
  npmDir: string;
  tagStyle: string;
  ghRelease: boolean;
  ghReleaseName?: string;
  ghReleaseId?: string;
  skipOptionalPublish: boolean;
  dryRun: boolean;
  getOptions(): {
    cwd: string;
    configPath: string | undefined;
    packageJsonPath: string;
    npmDir: string;
    tagStyle: string;
    ghRelease: boolean;
    ghReleaseName: string | undefined;
    ghReleaseId: string | undefined;
    skipOptionalPublish: boolean;
    dryRun: boolean;
  };
}
/**
 * Update package.json and copy addons into per platform packages
 */
interface PrePublishOptions {
  /**
   * The working directory of where napi command will be executed in, all other paths options are relative to this path
   *
   * @default process.cwd()
   */
  cwd?: string;
  /**
   * Path to `napi` config json file
   */
  configPath?: string;
  /**
   * Path to `package.json`
   *
   * @default 'package.json'
   */
  packageJsonPath?: string;
  /**
   * Path to the folder where the npm packages put
   *
   * @default 'npm'
   */
  npmDir?: string;
  /**
   * git tag style, `npm` or `lerna`
   *
   * @default 'lerna'
   */
  tagStyle?: 'npm' | 'lerna';
  /**
   * Whether create GitHub release
   *
   * @default true
   */
  ghRelease?: boolean;
  /**
   * GitHub release name
   */
  ghReleaseName?: string;
  /**
   * Existing GitHub release id
   */
  ghReleaseId?: string;
  /**
   * Whether skip optionalDependencies packages publish
   *
   * @default false
   */
  skipOptionalPublish?: boolean;
  /**
   * Dry run without touching file system
   *
   * @default false
   */
  dryRun?: boolean;
}
//#endregion
//#region src/api/pre-publish.d.ts
declare function prePublish(userOptions: PrePublishOptions): Promise<void>;
//#endregion
//#region src/def/rename.d.ts
declare abstract class BaseRenameCommand extends Command {
  static paths: string[][];
  static usage: _$clipanion.Usage;
  cwd: string;
  configPath?: string;
  packageJsonPath: string;
  npmDir: string;
  $$name?: string;
  binaryName?: string;
  packageName?: string;
  manifestPath: string;
  repository?: string;
  description?: string;
  getOptions(): {
    cwd: string;
    configPath: string | undefined;
    packageJsonPath: string;
    npmDir: string;
    name: string | undefined;
    binaryName: string | undefined;
    packageName: string | undefined;
    manifestPath: string;
    repository: string | undefined;
    description: string | undefined;
  };
}
/**
 * Rename the NAPI-RS project
 */
interface RenameOptions {
  /**
   * The working directory of where napi command will be executed in, all other paths options are relative to this path
   *
   * @default process.cwd()
   */
  cwd?: string;
  /**
   * Path to `napi` config json file
   */
  configPath?: string;
  /**
   * Path to `package.json`
   *
   * @default 'package.json'
   */
  packageJsonPath?: string;
  /**
   * Path to the folder where the npm packages put
   *
   * @default 'npm'
   */
  npmDir?: string;
  /**
   * The new name of the project
   */
  name?: string;
  /**
   * The new binary name *.node files
   */
  binaryName?: string;
  /**
   * The new package name of the project
   */
  packageName?: string;
  /**
   * Path to `Cargo.toml`
   *
   * @default 'Cargo.toml'
   */
  manifestPath?: string;
  /**
   * The new repository of the project
   */
  repository?: string;
  /**
   * The new description of the project
   */
  description?: string;
}
//#endregion
//#region src/api/rename.d.ts
declare function renameProject(userOptions: RenameOptions): Promise<void>;
//#endregion
//#region src/def/universalize.d.ts
declare abstract class BaseUniversalizeCommand extends Command {
  static paths: string[][];
  static usage: _$clipanion.Usage;
  cwd: string;
  configPath?: string;
  packageJsonPath: string;
  outputDir: string;
  getOptions(): {
    cwd: string;
    configPath: string | undefined;
    packageJsonPath: string;
    outputDir: string;
  };
}
/**
 * Combile built binaries into one universal binary
 */
interface UniversalizeOptions {
  /**
   * The working directory of where napi command will be executed in, all other paths options are relative to this path
   *
   * @default process.cwd()
   */
  cwd?: string;
  /**
   * Path to `napi` config json file
   */
  configPath?: string;
  /**
   * Path to `package.json`
   *
   * @default 'package.json'
   */
  packageJsonPath?: string;
  /**
   * Path to the folder where all built `.node` files put, same as `--output-dir` of build command
   *
   * @default './'
   */
  outputDir?: string;
}
//#endregion
//#region src/api/universalize.d.ts
declare function universalizeBinaries(userOptions: UniversalizeOptions): Promise<void>;
//#endregion
//#region src/def/version.d.ts
declare abstract class BaseVersionCommand extends Command {
  static paths: string[][];
  static usage: _$clipanion.Usage;
  cwd: string;
  configPath?: string;
  packageJsonPath: string;
  npmDir: string;
  getOptions(): {
    cwd: string;
    configPath: string | undefined;
    packageJsonPath: string;
    npmDir: string;
  };
}
/**
 * Update version in created npm packages
 */
interface VersionOptions {
  /**
   * The working directory of where napi command will be executed in, all other paths options are relative to this path
   *
   * @default process.cwd()
   */
  cwd?: string;
  /**
   * Path to `napi` config json file
   */
  configPath?: string;
  /**
   * Path to `package.json`
   *
   * @default 'package.json'
   */
  packageJsonPath?: string;
  /**
   * Path to the folder where the npm packages put
   *
   * @default 'npm'
   */
  npmDir?: string;
}
//#endregion
//#region src/api/version.d.ts
declare function version(userOptions: VersionOptions): Promise<void>;
//#endregion
//#region src/commands/artifacts.d.ts
declare class ArtifactsCommand extends BaseArtifactsCommand {
  static usage: _$clipanion.Usage;
  static paths: string[][];
  execute(): Promise<void>;
}
//#endregion
//#region src/commands/build.d.ts
declare class BuildCommand extends BaseBuildCommand {
  pipe: string | undefined;
  cargoOptions: string[];
  execute(): Promise<void>;
}
//#endregion
//#region src/commands/create-npm-dirs.d.ts
declare class CreateNpmDirsCommand extends BaseCreateNpmDirsCommand {
  execute(): Promise<void>;
}
//#endregion
//#region src/commands/new.d.ts
declare class NewCommand extends BaseNewCommand {
  interactive: boolean;
  execute(): Promise<1 | 0>;
  private fetchOptions;
  private fetchName;
  private fetchLicense;
  private fetchNapiVersion;
  private fetchTargets;
  private fetchTypeDef;
  private fetchGithubActions;
}
//#endregion
//#region src/commands/pre-publish.d.ts
declare class PrePublishCommand extends BasePrePublishCommand {
  execute(): Promise<void>;
}
//#endregion
//#region src/commands/rename.d.ts
declare class RenameCommand extends BaseRenameCommand {
  execute(): Promise<void>;
}
//#endregion
//#region src/commands/universalize.d.ts
declare class UniversalizeCommand extends BaseUniversalizeCommand {
  execute(): Promise<void>;
}
//#endregion
//#region src/commands/version.d.ts
declare class VersionCommand extends BaseVersionCommand {
  execute(): Promise<void>;
}
//#endregion
//#region src/utils/target.d.ts
type Platform = NodeJS.Platform | 'wasm' | 'wasi' | 'openharmony';
type NodeJSArch = 'arm' | 'arm64' | 'ia32' | 'loong64' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 'riscv64' | 's390' | 's390x' | 'x32' | 'x64' | 'universal' | 'wasm32';
interface Target {
  triple: string;
  platformArchABI: string;
  platform: Platform;
  arch: NodeJSArch;
  abi: string | null;
}
/**
 * A triple is a specific format for specifying a target architecture.
 * 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.
 * The general format of the triple is `<arch><sub>-<vendor>-<sys>-<abi>` where:
 *   - `arch` = The base CPU architecture, for example `x86_64`, `i686`, `arm`, `thumb`, `mips`, etc.
 *   - `sub` = The CPU sub-architecture, for example `arm` has `v7`, `v7s`, `v5te`, etc.
 *   - `vendor` = The vendor, for example `unknown`, `apple`, `pc`, `nvidia`, etc.
 *   - `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;
//#endregion
//#region src/utils/config.d.ts
interface UserNapiConfig {
  /**
   * Name of the binary to be generated, default to `index`
   */
  binaryName?: string;
  /**
   * Name of the npm package, default to the name of root package.json name
   *
   * Always given `@scope/pkg` and arch suffix will be appended like `@scope/pkg-linux-gnu-x64`
   */
  packageName?: string;
  /**
   * All targets the crate will be compiled for
   */
  targets?: string[];
  /**
   * The npm client project uses.
   */
  npmClient?: string;
  /**
   * Whether generate const enum for typescript bindings
   */
  constEnum?: boolean;
  /**
   * Emit `#[napi(string_enum)]` enums as runtime enums (`export declare enum`) under `--no-const-enum`. Default: type-only union.
   */
  runtimeStringEnum?: boolean;
  /**
   * dts header prepend to the generated dts file
   */
  dtsHeader?: string;
  /**
   * dts header file path to be prepended to the generated dts file
   * if both dtsHeader and dtsHeaderFile are provided, dtsHeaderFile will be used
   */
  dtsHeaderFile?: string;
  /**
   * wasm compilation options
   */
  wasm?: {
    /**
     * https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface/Memory
     * @default 4000 pages (256MiB)
     */
    initialMemory?: number;
    /**
     * @default 65536 pages (4GiB)
     */
    maximumMemory?: number;
    /**
     * Browser wasm binding configuration
     */
    browser: {
      /**
       * Whether to use fs module in browser
       */
      fs?: boolean;
      /**
       * Whether to initialize wasm asynchronously
       */
      asyncInit?: boolean;
      /**
       * Whether to inject `buffer` to emnapi context
       */
      buffer?: boolean;
      /**
       * Whether to emit custom events for errors in worker
       */
      errorEvent?: boolean;
    };
  };
  /**
   * @deprecated binaryName instead
   */
  name?: string;
  /**
   * @deprecated use packageName instead
   */
  package?: {
    name?: string;
  };
  /**
   * @deprecated use targets instead
   */
  triples?: {
    /**
     * Whether enable default targets
     */
    defaults: boolean;
    /**
     * Additional targets to be compiled for
     */
    additional?: string[];
  };
}
interface CommonPackageJsonFields {
  name: string;
  version: string;
  description?: string;
  keywords?: string[];
  author?: string;
  authors?: string[];
  license?: string;
  cpu?: string[];
  os?: string[];
  libc?: string[];
  files?: string[];
  repository?: any;
  homepage?: any;
  engines?: Record<string, string>;
  publishConfig?: any;
  bugs?: any;
  napi?: UserNapiConfig;
  type?: 'module' | 'commonjs';
  scripts?: Record<string, string>;
  main?: string;
  module?: string;
  types?: string;
  browser?: string;
  exports?: any;
  dependencies?: Record<string, string>;
  devDependencies?: Record<string, string>;
  ava?: {
    timeout?: string;
  };
}
type NapiConfig = Required<Pick<UserNapiConfig, 'binaryName' | 'packageName' | 'npmClient'>> & Pick<UserNapiConfig, 'wasm' | 'dtsHeader' | 'dtsHeaderFile' | 'constEnum' | 'runtimeStringEnum'> & {
  targets: Target[];
  packageJson: CommonPackageJsonFields;
};
declare function readNapiConfig(path: string, configPath?: string): Promise<NapiConfig>;
//#endregion
//#region src/index.d.ts
declare const cli: Cli<_$clipanion.BaseContext>;
/**
 *
 * @usage
 *
 * ```ts
 * const cli = new NapiCli()
 *
 * cli.build({
 *   cwd: '/path/to/your/project',
 * })
 * ```
 */
declare class NapiCli {
  artifacts: typeof collectArtifacts;
  new: typeof newProject;
  build: typeof buildProject;
  createNpmDirs: typeof createNpmDirs;
  prePublish: typeof prePublish;
  rename: typeof renameProject;
  universalize: typeof universalizeBinaries;
  version: typeof version;
}
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;
//#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":[],"sources":["../src/def/artifacts.d.ts","../src/api/artifacts.d.ts","../src/def/build.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/utils/target.d.ts","../src/utils/config.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 contains `wasm32-wasi-*`\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 contains `wasm32-wasi-*`\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    esm?: 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    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        esm: 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     * Whether to emit an ESM JS binding file instead of CJS format. Only works with `--platform` flag.\n     */\n    esm?: 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 for the specified target with `cargo-xwin` on windows and `cargo-zigbuild` on other platform\n     */\n    crossCompile?: boolean;\n    /**\n     * [experimental] use [cross](https://github.com/cross-rs/cross) instead of `cargo`\n     */\n    useCross?: boolean;\n    /**\n     * [experimental] use @napi-rs/cross-toolchain to cross-compile Linux arm/arm64/x64 gnu targets.\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     * Whether to emit an ESM JS binding file instead of CJS format. Only works with `--platform` flag.\n     */\n    esm?: 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 for the specified target with `cargo-xwin` on windows and `cargo-zigbuild` on other platform\n     */\n    crossCompile?: boolean;\n    /**\n     * [experimental] use [cross](https://github.com/cross-rs/cross) instead of `cargo`\n     */\n    useCross?: boolean;\n    /**\n     * [experimental] use @napi-rs/cross-toolchain to cross-compile Linux arm/arm64/x64 gnu targets.\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","import type { BuildOptions as RawBuildOptions } from '../def/build.js';\ntype OutputKind = 'js' | 'dts' | 'node' | 'exe' | 'wasm';\ntype Output = {\n    kind: OutputKind;\n    path: string;\n};\ntype BuildOptions = RawBuildOptions & {\n    cargoOptions?: string[];\n};\nexport declare function buildProject(rawOptions: BuildOptions): Promise<{\n    task: Promise<Output[]>;\n    abort: () => void;\n}>;\nexport interface WriteJsBindingOptions {\n    platform?: boolean;\n    noJsBinding?: boolean;\n    idents: string[];\n    jsBinding?: string;\n    esm?: boolean;\n    binaryName: string;\n    packageName: string;\n    version: string;\n    outputDir: string;\n}\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}>;\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 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    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        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     * 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    dryRun: boolean;\n};\n","import { type PrePublishOptions } from '../def/pre-publish.js';\nexport declare function prePublish(userOptions: PrePublishOptions): Promise<void>;\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<1 | 0>;\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","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-wasi-preview1-threads\", \"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}\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;\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>;\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     * 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 (256MiB)\n         */\n        initialMemory?: number;\n        /**\n         * @default 65536 pages (4GiB)\n         */\n        maximumMemory?: number;\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    ava?: {\n        timeout?: string;\n    };\n}\nexport type NapiConfig = Required<Pick<UserNapiConfig, 'binaryName' | 'packageName' | 'npmClient'>> & Pick<UserNapiConfig, 'wasm' | 'dtsHeader' | 'dtsHeaderFile' | 'constEnum' | 'runtimeStringEnum'> & {\n    targets: Target[];\n    packageJson: CommonPackageJsonFields;\n};\nexport declare function readNapiConfig(path: string, configPath?: string): Promise<NapiConfig>;\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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"}