type MaybePromise<T> = T | Promise<T>
type Nullable<T> = T | null | undefined
type VoidNullable<T = void> = T | null | undefined | void
export type BindingStringOrRegex = string | RegExp
export type BindingResult<T> = { errors: BindingError[], isBindingErrors: boolean } | T

export interface CodegenOptions {
  /**
   * Remove whitespace.
   *
   * @default true
   */
  removeWhitespace?: boolean
  /**
   * How to handle legal comments (comments containing `@license`, `@preserve`, or starting with `//!`/`/*!`).
   *
   * * `"none"` - Do not preserve any legal comments.
   * * `"inline"` - Preserve all legal comments inline.
   * * `"eof"` - Move all legal comments to the end of the file.
   * * `"external"` - Extract legal comments without linking.
   * * `{ linked: "path/to/legal.txt" }` - Extract legal comments and add a link comment to the given path.
   *
   * @default "none" (when minifying)
   */
legalComments?: 'none' | 'inline' | 'eof' | 'external' | { linked: string }
}

export interface CompressOptions {
  /**
   * Set desired EcmaScript standard version for output.
   *
   * Set `esnext` to enable all target highering.
   *
   * Example:
   *
   * * `'es2015'`
   * * `['es2020', 'chrome58', 'edge16', 'firefox57', 'node12', 'safari11']`
   *
   * @default 'esnext'
   *
   * @see [oxc#target](https://oxc.rs/docs/guide/usage/transformer/lowering#target)
   */
  target?: string | Array<string>
  /**
   * Pass true to discard calls to `console.*`.
   *
   * @default false
   */
  dropConsole?: boolean
  /**
   * Remove `debugger;` statements.
   *
   * @default true
   */
  dropDebugger?: boolean
  /**
   * Pass `true` to drop unreferenced functions and variables.
   *
   * Simple direct variable assignments do not count as references unless set to `keep_assign`.
   * @default true
   */
  unused?: boolean | 'keep_assign'
  /** Keep function / class names. */
  keepNames?: CompressOptionsKeepNames
  /**
   * Join consecutive var, let and const statements.
   *
   * @default true
   */
  joinVars?: boolean
  /**
   * Join consecutive simple statements using the comma operator.
   *
   * `a; b` -> `a, b`
   *
   * @default true
   */
  sequences?: boolean
  /**
   * Set of label names to drop from the code.
   *
   * Labeled statements matching these names will be removed during minification.
   *
   * @default []
   */
  dropLabels?: Array<string>
  /** Limit the maximum number of iterations for debugging purpose. */
  maxIterations?: number
  /** Treeshake options. */
  treeshake?: TreeShakeOptions
}

export interface CompressOptionsKeepNames {
  /**
   * Keep function names so that `Function.prototype.name` is preserved.
   *
   * This does not guarantee that the `undefined` name is preserved.
   *
   * @default false
   */
  function: boolean
  /**
   * Keep class names so that `Class.prototype.name` is preserved.
   *
   * This does not guarantee that the `undefined` name is preserved.
   *
   * @default false
   */
  class: boolean
}

export interface LegalCommentsLinked {
  /**
   * Extract legal comments and write them to the given path, with a link
   * comment appended to the generated code.
   */
  linked: string
}

export type LegalCommentsMode = /** Do not preserve any legal comments. */
'none'|
/** Preserve all legal comments inline. */
'inline'|
/** Move all legal comments to the end of the file. */
'eof'|
/** Extract legal comments without linking. */
'external';

export interface MangleOptions {
  /**
   * Pass `true` to mangle names declared in the top level scope.
   *
   * @default true for modules and commonjs, otherwise false
   */
  toplevel?: boolean
  /**
   * Preserve `name` property for functions and classes.
   *
   * @default false
   */
  keepNames?: boolean | MangleOptionsKeepNames
  /**
   * Names that bindings must not be renamed to, and that bindings already
   * carrying them keep. Equivalent to terser's `mangle.reserved`.
   *
   * Pass `['exports', 'module']` when minifying prebuilt CommonJS / UMD files
   * that Node consumers `import` directly, so Node's cjs-module-lexer can still
   * detect the mangled module's named exports.
   *
   * @default []
   */
  reserved?: Array<string>
  /** Debug mangled names. */
  debug?: boolean
}

export interface MangleOptionsKeepNames {
  /**
   * Preserve `name` property for functions.
   *
   * @default false
   */
  function: boolean
  /**
   * Preserve `name` property for classes.
   *
   * @default false
   */
  class: boolean
}

/**
 * Minify asynchronously.
 *
 * Note: This function can be slower than `minifySync` due to the overhead of spawning a thread.
 */
export declare function minify(filename: string, sourceText: string, options?: MinifyOptions | undefined | null): Promise<MinifyResult>

export interface MinifyOptions {
  /** Use when minifying an ES module. */
  module?: boolean
  compress?: boolean | CompressOptions
  mangle?: boolean | MangleOptions
  codegen?: boolean | CodegenOptions
  sourcemap?: boolean
}

export interface MinifyResult {
  code: string
  map?: SourceMap
  errors: Array<OxcError>
  /**
   * Legal comments extracted from the source code.
   * Only populated when `codegen.legalComments` is `"linked"` or `"external"`.
   */
  legalComments: Array<string>
}

/** Minify synchronously. */
export declare function minifySync(filename: string, sourceText: string, options?: MinifyOptions | undefined | null): MinifyResult

export interface TreeShakeOptions {
  /**
   * Whether to respect the pure annotations.
   *
   * Pure annotations are comments that mark an expression as pure.
   * For example: @__PURE__ or #__NO_SIDE_EFFECTS__.
   *
   * @default true
   */
  annotations?: boolean
  /**
   * Whether to treat this function call as pure.
   *
   * This function is called for normal function calls, new calls, and
   * tagged template calls.
   */
  manualPureFunctions?: Array<string>
  /**
   * Whether property read accesses have side effects.
   *
   * @default 'always'
   */
  propertyReadSideEffects?: boolean | 'always'
  /**
   * Whether property write accesses (assignments to member expressions) have side effects.
   *
   * When false, assignments like `obj.prop = value` are considered side-effect-free
   * (assuming the object and value expressions themselves are side-effect-free).
   *
   * @default true
   */
  propertyWriteSideEffects?: boolean
  /**
   * Whether accessing a global variable has side effects.
   *
   * Accessing a non-existing global variable will throw an error.
   * Global variable may be a getter that has side effects.
   *
   * @default true
   */
  unknownGlobalSideEffects?: boolean
  /**
   * Whether invalid import statements have side effects.
   *
   * Accessing a non-existing import name will throw an error.
   * Also import statements that cannot be resolved will throw an error.
   *
   * @default true
   */
  invalidImportSideEffects?: boolean
}
export interface Comment {
  type: 'Line' | 'Block'
  value: string
  start: number
  end: number
}

export interface ErrorLabel {
  message: string | null
  start: number
  end: number
}

export interface OxcError {
  severity: Severity
  message: string
  labels: Array<ErrorLabel>
  helpMessage: string | null
  codeframe: string | null
}

export type Severity =  'Error'|
'Warning'|
'Advice';
export declare class ParseResult {
  get program(): import("@oxc-project/types").Program
  get module(): EcmaScriptModule
  get comments(): Array<Comment>
  get errors(): Array<OxcError>
}

export interface DynamicImport {
  start: number
  end: number
  moduleRequest: Span
}

export interface EcmaScriptModule {
  /**
   * Has ESM syntax.
   *
   * i.e. `import` and `export` statements, and `import.meta`.
   *
   * Dynamic imports `import('foo')` are ignored since they can be used in non-ESM files.
   */
  hasModuleSyntax: boolean
  /** Import statements. */
  staticImports: Array<StaticImport>
  /** Export statements. */
  staticExports: Array<StaticExport>
  /** Dynamic import expressions. */
  dynamicImports: Array<DynamicImport>
  /** Span positions` of `import.meta` */
  importMetas: Array<Span>
}

export interface ExportExportName {
  kind: ExportExportNameKind
  name: string | null
  start: number | null
  end: number | null
}

export type ExportExportNameKind = /** `export { name } */
'Name'|
/** `export default expression` */
'Default'|
/** `export * from "mod" */
'None';

export interface ExportImportName {
  kind: ExportImportNameKind
  name: string | null
  start: number | null
  end: number | null
}

export type ExportImportNameKind = /** `export { name } */
'Name'|
/** `export * as ns from "mod"` */
'All'|
/** `export * from "mod"` */
'AllButDefault'|
/** Does not have a specifier. */
'None';

export interface ExportLocalName {
  kind: ExportLocalNameKind
  name: string | null
  start: number | null
  end: number | null
}

export type ExportLocalNameKind = /** `export { name } */
'Name'|
/** `export default expression` */
'Default'|
/**
 * If the exported value is not locally accessible from within the module.
 * `export default function () {}`
 */
'None';

export interface ImportName {
  kind: ImportNameKind
  name: string | null
  start: number | null
  end: number | null
}

export type ImportNameKind = /** `import { x } from "mod"` */
'Name'|
/** `import * as ns from "mod"` */
'NamespaceObject'|
/** `import defaultExport from "mod"` */
'Default';

/**
 * Parse JS/TS source asynchronously on a separate thread.
 *
 * Note that not all of the workload can happen on a separate thread.
 * Parsing on Rust side does happen in a separate thread, but deserialization of the AST to JS objects
 * has to happen on current thread. This synchronous deserialization work typically outweighs
 * the asynchronous parsing by a factor of between 3 and 20.
 *
 * i.e. the majority of the workload cannot be parallelized by using this method.
 *
 * Generally `parseSync` is preferable to use as it does not have the overhead of spawning a thread.
 * If you need to parallelize parsing multiple files, it is recommended to use worker threads.
 */
export declare function parse(filename: string, sourceText: string, options?: ParserOptions | undefined | null): Promise<ParseResult>

export interface ParserOptions {
  /** Treat the source text as `js`, `jsx`, `ts`, `tsx` or `dts`. */
  lang?: 'js' | 'jsx' | 'ts' | 'tsx' | 'dts'
  /** Treat the source text as `script` or `module` code. */
  sourceType?: 'script' | 'module' | 'commonjs' | 'unambiguous' | undefined
  /**
   * Return an AST which includes TypeScript-related properties, or excludes them.
   *
   * `'js'` is default for JS / JSX files.
   * `'ts'` is default for TS / TSX files.
   * The type of the file is determined from `lang` option, or extension of provided `filename`.
   */
  astType?: 'js' | 'ts'
  /**
   * Controls whether the `range` property is included on AST nodes.
   * The `range` property is a `[number, number]` which indicates the start/end offsets
   * of the node in the file contents.
   *
   * @default false
   */
  range?: boolean
  /**
   * Emit `ParenthesizedExpression` and `TSParenthesizedType` in AST.
   *
   * If this option is true, parenthesized expressions are represented by
   * (non-standard) `ParenthesizedExpression` and `TSParenthesizedType` nodes that
   * have a single `expression` property containing the expression inside parentheses.
   *
   * @default true
   */
  preserveParens?: boolean
  /**
   * Produce semantic errors with an additional AST pass.
   * Semantic errors depend on symbols and scopes, where the parser does not construct.
   * This adds a small performance overhead.
   *
   * @default false
   */
  showSemanticErrors?: boolean
}

/**
 * Parse JS/TS source synchronously on current thread.
 *
 * This is generally preferable over `parse` (async) as it does not have the overhead
 * of spawning a thread, and the majority of the workload cannot be parallelized anyway
 * (see `parse` documentation for details).
 *
 * If you need to parallelize parsing multiple files, it is recommended to use worker threads
 * with `parseSync` rather than using `parse`.
 */
export declare function parseSync(filename: string, sourceText: string, options?: ParserOptions | undefined | null): ParseResult

/** Returns `true` if raw transfer is supported on this platform. */
export declare function rawTransferSupported(): boolean

export interface Span {
  start: number
  end: number
}

export interface StaticExport {
  start: number
  end: number
  entries: Array<StaticExportEntry>
}

export interface StaticExportEntry {
  start: number
  end: number
  moduleRequest: ValueSpan | null
  /** The name under which the desired binding is exported by the module`. */
  importName: ExportImportName
  /** The name used to export this binding by this module. */
  exportName: ExportExportName
  /** The name that is used to locally access the exported value from within the importing module. */
  localName: ExportLocalName
  /**
   * Whether the export is a TypeScript `export type`.
   *
   * Examples:
   *
   * ```ts
   * export type * from 'mod';
   * export type * as ns from 'mod';
   * export type { foo };
   * export { type foo }:
   * export type { foo } from 'mod';
   * ```
   */
  isType: boolean
}

export interface StaticImport {
  /** Start of import statement. */
  start: number
  /** End of import statement. */
  end: number
  /**
   * Import source.
   *
   * ```js
   * import { foo } from "mod";
   * //                   ^^^
   * ```
   */
  moduleRequest: ValueSpan
  /**
   * Import specifiers.
   *
   * Empty for `import "mod"`.
   */
  entries: Array<StaticImportEntry>
}

export interface StaticImportEntry {
  /**
   * The name under which the desired binding is exported by the module.
   *
   * ```js
   * import { foo } from "mod";
   * //       ^^^
   * import { foo as bar } from "mod";
   * //       ^^^
   * ```
   */
  importName: ImportName
  /**
   * The name that is used to locally access the imported value from within the importing module.
   * ```js
   * import { foo } from "mod";
   * //       ^^^
   * import { foo as bar } from "mod";
   * //              ^^^
   * ```
   */
  localName: ValueSpan
  /**
   * Whether this binding is for a TypeScript type-only import.
   *
   * `true` for the following imports:
   * ```ts
   * import type { foo } from "mod";
   * import { type foo } from "mod";
   * ```
   */
  isType: boolean
}

export interface ValueSpan {
  value: string
  start: number
  end: number
}
export declare class ResolverFactory {
  constructor(options?: NapiResolveOptions | undefined | null)
  static default(): ResolverFactory
  /** Clone the resolver using the same underlying cache. */
  cloneWithOptions(options: NapiResolveOptions): ResolverFactory
  /**
   * Clear the underlying cache.
   *
   * Warning: The caller must ensure that there're no ongoing resolution operations when calling this method. Otherwise, it may cause those operations to return an incorrect result.
   */
  clearCache(): void
  /** Synchronously resolve `specifier` at an absolute path to a `directory`. */
  sync(directory: string, request: string): ResolveResult
  /** Asynchronously resolve `specifier` at an absolute path to a `directory`. */
  async(directory: string, request: string): Promise<ResolveResult>
  /**
   * Synchronously resolve `specifier` at an absolute path to a `file`.
   *
   * This method automatically discovers tsconfig.json by traversing parent directories.
   */
  resolveFileSync(file: string, request: string): ResolveResult
  /**
   * Asynchronously resolve `specifier` at an absolute path to a `file`.
   *
   * This method automatically discovers tsconfig.json by traversing parent directories.
   */
  resolveFileAsync(file: string, request: string): Promise<ResolveResult>
  /**
   * Synchronously resolve `specifier` for TypeScript declaration files.
   *
   * `file` is the absolute path to the containing file.
   * Uses TypeScript's `moduleResolution: "bundler"` algorithm.
   */
  resolveDtsSync(file: string, request: string): ResolveResult
  /**
   * Asynchronously resolve `specifier` for TypeScript declaration files.
   *
   * `file` is the absolute path to the containing file.
   * Uses TypeScript's `moduleResolution: "bundler"` algorithm.
   */
  resolveDtsAsync(file: string, request: string): Promise<ResolveResult>
}

/** Node.js builtin module when `Options::builtin_modules` is enabled. */
export interface Builtin {
  /**
   * Resolved module.
   *
   * Always prefixed with "node:" in compliance with the ESM specification.
   */
  resolved: string
  /**
   * Whether the request was prefixed with `node:` or not.
   * `fs` -> `false`.
   * `node:fs` returns `true`.
   */
  isRuntimeModule: boolean
}

export declare enum EnforceExtension {
  Auto = 0,
  Enabled = 1,
  Disabled = 2
}

export type ModuleType =  'module'|
'commonjs'|
'json'|
'wasm'|
'addon';

/**
 * Module Resolution Options
 *
 * Options are directly ported from [enhanced-resolve](https://github.com/webpack/enhanced-resolve#resolver-options).
 *
 * See [webpack resolve](https://webpack.js.org/configuration/resolve/) for information and examples
 */
export interface NapiResolveOptions {
  /**
   * Discover tsconfig automatically or use the specified tsconfig.json path.
   *
   * Default `None`
   */
  tsconfig?: 'auto' | TsconfigOptions
  /**
   * Alias for [ResolveOptions::alias] and [ResolveOptions::fallback].
   *
   * For the second value of the tuple, `None -> AliasValue::Ignore`, Some(String) ->
   * AliasValue::Path(String)`
   * Create aliases to import or require certain modules more easily.
   * A trailing $ can also be added to the given object's keys to signify an exact match.
   * Default `{}`
   */
  alias?: Record<string, Array<string | undefined | null>>
  /**
   * A list of alias fields in description files.
   * Specify a field, such as `browser`, to be parsed according to [this specification](https://github.com/defunctzombie/package-browser-field-spec).
   * Can be a path to json object such as `["path", "to", "exports"]`.
   *
   * Default `[]`
   */
  aliasFields?: (string | string[])[]
  /**
   * Condition names for exports field which defines entry points of a package.
   * The key order in the exports field is significant. During condition matching, earlier entries have higher priority and take precedence over later entries.
   *
   * Default `[]`
   */
  conditionNames?: Array<string>
  /**
   * If true, it will not allow extension-less files.
   * So by default `require('./foo')` works if `./foo` has a `.js` extension,
   * but with this enabled only `require('./foo.js')` will work.
   *
   * Default to `true` when [ResolveOptions::extensions] contains an empty string.
   * Use `Some(false)` to disable the behavior.
   * See <https://github.com/webpack/enhanced-resolve/pull/285>
   *
   * Default None, which is the same as `Some(false)` when the above empty rule is not applied.
   */
  enforceExtension?: EnforceExtension
  /**
   * A list of exports fields in description files.
   * Can be a path to json object such as `["path", "to", "exports"]`.
   *
   * Default `[["exports"]]`.
   */
  exportsFields?: (string | string[])[]
  /**
   * Fields from `package.json` which are used to provide the internal requests of a package
   * (requests starting with # are considered internal).
   *
   * Can be a path to a JSON object such as `["path", "to", "imports"]`.
   *
   * Default `[["imports"]]`.
   */
  importsFields?: (string | string[])[]
  /**
   * An object which maps extension to extension aliases.
   *
   * Default `{}`
   */
  extensionAlias?: Record<string, Array<string>>
  /**
   * Attempt to resolve these extensions in order.
   * If multiple files share the same name but have different extensions,
   * will resolve the one with the extension listed first in the array and skip the rest.
   *
   * Default `[".js", ".json", ".node"]`
   */
  extensions?: Array<string>
  /**
   * Redirect module requests when normal resolving fails.
   *
   * Default `{}`
   */
  fallback?: Record<string, Array<string | undefined | null>>
  /**
   * Request passed to resolve is already fully specified and extensions or main files are not resolved for it (they are still resolved for internal requests).
   *
   * See also webpack configuration [resolve.fullySpecified](https://webpack.js.org/configuration/module/#resolvefullyspecified)
   *
   * Default `false`
   */
  fullySpecified?: boolean
  /**
   * A list of main fields in description files
   *
   * Default `["main"]`.
   */
  mainFields?: string | string[]
  /**
   * The filename to be used while resolving directories.
   *
   * Default `["index"]`
   */
  mainFiles?: Array<string>
  /**
   * A list of directories to resolve modules from, can be absolute path or folder name.
   *
   * Default `["node_modules"]`
   */
  modules?: string | string[]
  /**
   * Resolve to a context instead of a file.
   *
   * Default `false`
   */
  resolveToContext?: boolean
  /**
   * Prefer to resolve module requests as relative requests instead of using modules from node_modules directories.
   *
   * Default `false`
   */
  preferRelative?: boolean
  /**
   * Prefer to resolve server-relative urls as absolute paths before falling back to resolve in ResolveOptions::roots.
   *
   * Default `false`
   */
  preferAbsolute?: boolean
  /**
   * A list of resolve restrictions to restrict the paths that a request can be resolved on.
   *
   * Default `[]`
   */
  restrictions?: Array<Restriction>
  /**
   * A list of directories where requests of server-relative URLs (starting with '/') are resolved.
   * On non-Windows systems these requests are resolved as an absolute path first.
   *
   * Default `[]`
   */
  roots?: Array<string>
  /**
   * Whether to resolve symlinks to their symlinked location.
   * When enabled, symlinked resources are resolved to their real path, not their symlinked location.
   * Note that this may cause module resolution to fail when using tools that symlink packages (like npm link).
   *
   * Default `true`
   */
  symlinks?: boolean
  /**
   * Whether to read the `NODE_PATH` environment variable and append its entries to `modules`.
   *
   * `NODE_PATH` is a deprecated Node.js feature that is not part of ESM resolution.
   * Set this to `false` to disable the behavior.
   *
   * Default `true`
   */
  nodePath?: boolean
  /**
   * Whether to parse [module.builtinModules](https://nodejs.org/api/module.html#modulebuiltinmodules) or not.
   * For example, "zlib" will throw [crate::ResolveError::Builtin] when set to true.
   *
   * Default `false`
   */
  builtinModules?: boolean
  /**
   * Resolve [ResolveResult::moduleType].
   *
   * Default `false`
   */
  moduleType?: boolean
  /**
   * Allow `exports` field in `require('../directory')`.
   *
   * This is not part of the spec but some vite projects rely on this behavior.
   * See
   * * <https://github.com/vitejs/vite/pull/20252>
   * * <https://github.com/nodejs/node/issues/58827>
   *
   * Default: `false`
   */
  allowPackageExportsInDirectoryResolve?: boolean
}

export interface ResolveResult {
  path?: string
  error?: string
  builtin?: Builtin
  /**
   * Module type for this path.
   *
   * Enable with `ResolveOptions#moduleType`.
   *
   * The module type is computed `ESM_FILE_FORMAT` from the [ESM resolution algorithm specification](https://nodejs.org/docs/latest/api/esm.html#resolution-algorithm-specification).
   *
   *  The algorithm uses the file extension or finds the closest `package.json` with the `type` field.
   */
  moduleType?: ModuleType
  /** `package.json` path for the given module. */
  packageJsonPath?: string
}

/**
 * Alias Value for [ResolveOptions::alias] and [ResolveOptions::fallback].
 * Use struct because napi don't support structured union now
 */
export interface Restriction {
  path?: string
  regex?: string
}

export declare function sync(path: string, request: string): ResolveResult

/**
 * Tsconfig Options
 *
 * Derived from [tsconfig-paths-webpack-plugin](https://github.com/dividab/tsconfig-paths-webpack-plugin#options)
 */
export interface TsconfigOptions {
  /**
   * Allows you to specify where to find the TypeScript configuration file.
   * You may provide
   * * a relative path to the configuration file. It will be resolved relative to cwd.
   * * an absolute path to the configuration file.
   */
  configFile: string
  /**
   * Support for Typescript Project References.
   *
   * * `'auto'`: use the `references` field from tsconfig of `config_file`.
   */
  references?: 'auto'
}
export interface SourceMap {
  file?: string
  mappings: string
  names: Array<string>
  sourceRoot?: string
  sources: Array<string>
  sourcesContent?: Array<string>
  version: number
  x_google_ignoreList?: Array<number>
}
export interface ArrowFunctionsOptions {
  /**
   * This option enables the following:
   * * Wrap the generated function in .bind(this) and keeps uses of this inside the function as-is, instead of using a renamed this.
   * * Add a runtime check to ensure the functions are not instantiated.
   * * Add names to arrow functions.
   *
   * @default false
   */
  spec?: boolean
}

export interface CompilerAssumptions {
  ignoreFunctionLength?: boolean
  noDocumentAll?: boolean
  objectRestNoSymbols?: boolean
  pureGetters?: boolean
  /**
   * When using public class fields, assume that they don't shadow any getter in the current class,
   * in its subclasses or in its superclass. Thus, it's safe to assign them rather than using
   * `Object.defineProperty`.
   *
   * For example:
   *
   * Input:
   * ```js
   * class Test {
   *  field = 2;
   *
   *  static staticField = 3;
   * }
   * ```
   *
   * When `set_public_class_fields` is `true`, the output will be:
   * ```js
   * class Test {
   *  constructor() {
   *    this.field = 2;
   *  }
   * }
   * Test.staticField = 3;
   * ```
   *
   * Otherwise, the output will be:
   * ```js
   * import _defineProperty from "@oxc-project/runtime/helpers/defineProperty";
   * class Test {
   *   constructor() {
   *     _defineProperty(this, "field", 2);
   *   }
   * }
   * _defineProperty(Test, "staticField", 3);
   * ```
   *
   * NOTE: For TypeScript, if you wanted behavior is equivalent to `useDefineForClassFields: false`, you should
   * set both `set_public_class_fields` and [`crate::TypeScriptOptions::remove_class_fields_without_initializer`]
   * to `true`.
   */
  setPublicClassFields?: boolean
}

export interface DecoratorOptions {
  /**
   * Enables experimental support for decorators, which is a version of decorators that predates the TC39 standardization process.
   *
   * Decorators are a language feature which hasn’t yet been fully ratified into the JavaScript specification.
   * This means that the implementation version in TypeScript may differ from the implementation in JavaScript when it it decided by TC39.
   *
   * @see https://www.typescriptlang.org/tsconfig/#experimentalDecorators
   * @default false
   */
  legacy?: boolean
  /**
   * Enables emitting decorator metadata.
   *
   * This option the same as [emitDecoratorMetadata](https://www.typescriptlang.org/tsconfig/#emitDecoratorMetadata)
   * in TypeScript, and it only works when `legacy` is true.
   *
   * @see https://www.typescriptlang.org/tsconfig/#emitDecoratorMetadata
   * @default false
   */
  emitDecoratorMetadata?: boolean
  /**
   * Aligns nullable-union `design:type` emission with `--strictNullChecks`.
   *
   * When `true` (default), `T | null` and `T | undefined` emit `Object`, matching tsc strict.
   * When `false`, `null` and `undefined` are elided from the union so the underlying
   * primitive constructor is emitted, matching tsc with `--strictNullChecks=false`
   * and `babel-plugin-transform-typescript-metadata`.
   *
   * @see https://www.typescriptlang.org/tsconfig/#strictNullChecks
   * @default true
   */
  strictNullChecks?: boolean
}

export interface Es2015Options {
  /** Transform arrow functions into function expressions. */
  arrowFunction?: ArrowFunctionsOptions
}

export type HelperMode = /**
 * Runtime mode (default): Helper functions are imported from a runtime package.
 *
 * Example:
 *
 * ```js
 * import helperName from "@oxc-project/runtime/helpers/helperName";
 * helperName(...arguments);
 * ```
 */
'Runtime'|
/**
 * External mode: Helper functions are accessed from a global `babelHelpers` object.
 *
 * Example:
 *
 * ```js
 * babelHelpers.helperName(...arguments);
 * ```
 */
'External';

export interface Helpers {
  mode?: HelperMode
}

/**
 * TypeScript Isolated Declarations for Standalone DTS Emit (async)
 *
 * Note: This function can be slower than `isolatedDeclarationSync` due to the overhead of spawning a thread.
 */
export declare function isolatedDeclaration(filename: string, sourceText: string, options?: IsolatedDeclarationsOptions | undefined | null): Promise<IsolatedDeclarationsResult>

export interface IsolatedDeclarationsOptions {
  /**
   * Do not emit declarations for code that has an @internal annotation in its JSDoc comment.
   * This is an internal compiler option; use at your own risk, because the compiler does not check that the result is valid.
   *
   * Default: `false`
   *
   * See <https://www.typescriptlang.org/tsconfig/#stripInternal>
   */
  stripInternal?: boolean
  sourcemap?: boolean
}

export interface IsolatedDeclarationsResult {
  code: string
  map?: SourceMap
  errors: Array<OxcError>
}

/** TypeScript Isolated Declarations for Standalone DTS Emit */
export declare function isolatedDeclarationSync(filename: string, sourceText: string, options?: IsolatedDeclarationsOptions | undefined | null): IsolatedDeclarationsResult

/**
 * Configure how TSX and JSX are transformed.
 *
 * @see {@link https://oxc.rs/docs/guide/usage/transformer/jsx}
 */
export interface JsxOptions {
  /**
   * Decides which runtime to use.
   *
   * - 'automatic' - auto-import the correct JSX factories
   * - 'classic' - no auto-import
   *
   * @default 'automatic'
   */
  runtime?: 'classic' | 'automatic'
  /**
   * Emit development-specific information, such as `__source` and `__self`.
   *
   * @default false
   */
  development?: boolean
  /**
   * Toggles whether or not to throw an error if an XML namespaced tag name
   * is used.
   *
   * Though the JSX spec allows this, it is disabled by default since React's
   * JSX does not currently have support for it.
   *
   * @default true
   */
  throwIfNamespace?: boolean
  /**
   * Mark JSX elements and top-level React method calls as pure for tree shaking.
   *
   * @default true
   */
  pure?: boolean
  /**
   * Replaces the import source when importing functions.
   *
   * @default 'react'
   */
  importSource?: string
  /**
   * Replace the function used when compiling JSX expressions. It should be a
   * qualified name (e.g. `React.createElement`) or an identifier (e.g.
   * `createElement`).
   *
   * Only used for `classic` {@link runtime}.
   *
   * @default 'React.createElement'
   */
  pragma?: string
  /**
   * Replace the component used when compiling JSX fragments. It should be a
   * valid JSX tag name.
   *
   * Only used for `classic` {@link runtime}.
   *
   * @default 'React.Fragment'
   */
  pragmaFrag?: string
  /**
   * Enable React Fast Refresh .
   *
   * Conforms to the implementation in {@link https://github.com/facebook/react/tree/v18.3.1/packages/react-refresh}
   *
   * @default false
   */
  refresh?: boolean | ReactRefreshOptions
}

/**
 * Transform JavaScript code to a Vite Node runnable module.
 *
 * @param filename The name of the file being transformed.
 * @param sourceText the source code itself
 * @param options The options for the transformation. See {@link
 * ModuleRunnerTransformOptions} for more information.
 *
 * @returns an object containing the transformed code, source maps, and any
 * errors that occurred during parsing or transformation.
 *
 * Note: This function can be slower than `moduleRunnerTransformSync` due to the overhead of spawning a thread.
 *
 * @deprecated Only works for Vite.
 */
export declare function moduleRunnerTransform(filename: string, sourceText: string, options?: ModuleRunnerTransformOptions | undefined | null): Promise<ModuleRunnerTransformResult>

export interface ModuleRunnerTransformOptions {
  /**
   * Enable source map generation.
   *
   * When `true`, the `sourceMap` field of transform result objects will be populated.
   *
   * @default false
   *
   * @see {@link SourceMap}
   */
  sourcemap?: boolean
}

export interface ModuleRunnerTransformResult {
  /**
   * The transformed code.
   *
   * If parsing failed, this will be an empty string.
   */
  code: string
  /**
   * The source map for the transformed code.
   *
   * This will be set if {@link TransformOptions#sourcemap} is `true`.
   */
  map?: SourceMap
  deps: Array<string>
  dynamicDeps: Array<string>
  /**
   * Parse and transformation errors.
   *
   * Oxc's parser recovers from common syntax errors, meaning that
   * transformed code may still be available even if there are errors in this
   * list.
   */
  errors: Array<OxcError>
}

/** @deprecated Only works for Vite. */
export declare function moduleRunnerTransformSync(filename: string, sourceText: string, options?: ModuleRunnerTransformOptions | undefined | null): ModuleRunnerTransformResult

export interface PluginsOptions {
  styledComponents?: StyledComponentsOptions
  taggedTemplateEscape?: boolean
}

export interface ReactRefreshOptions {
  /**
   * Specify the identifier of the refresh registration variable.
   *
   * @default `$RefreshReg$`.
   */
  refreshReg?: string
  /**
   * Specify the identifier of the refresh signature variable.
   *
   * @default `$RefreshSig$`.
   */
  refreshSig?: string
  emitFullSignatures?: boolean
}

/**
 * Configure how styled-components are transformed.
 *
 * @see {@link https://oxc.rs/docs/guide/usage/transformer/plugins#styled-components}
 */
export interface StyledComponentsOptions {
  /**
   * Enhances the attached CSS class name on each component with richer output to help
   * identify your components in the DOM without React DevTools.
   *
   * @default true
   */
  displayName?: boolean
  /**
   * Controls whether the `displayName` of a component will be prefixed with the filename
   * to make the component name as unique as possible.
   *
   * @default true
   */
  fileName?: boolean
  /**
   * Adds a unique identifier to every styled component to avoid checksum mismatches
   * due to different class generation on the client and server during server-side rendering.
   *
   * @default true
   */
  ssr?: boolean
  /**
   * Transpiles styled-components tagged template literals to a smaller representation
   * than what Babel normally creates, helping to reduce bundle size.
   *
   * Disabled by default because Oxc does not down-level template literals, so this
   * transform only increases output size.
   *
   * @default false
   */
  transpileTemplateLiterals?: boolean
  /**
   * Minifies CSS content by removing all whitespace and comments from your CSS,
   * keeping valuable bytes out of your bundles.
   *
   * @default true
   */
  minify?: boolean
  /**
   * Enables transformation of JSX `css` prop when using styled-components.
   *
   * **Note: This feature is not yet implemented in oxc.**
   *
   * @default true
   */
  cssProp?: boolean
  /**
   * Enables "pure annotation" to aid dead code elimination by bundlers.
   *
   * @default false
   */
  pure?: boolean
  /**
   * Adds a namespace prefix to component identifiers to ensure class names are unique.
   *
   * Example: With `namespace: "my-app"`, generates `componentId: "my-app__sc-3rfj0a-1"`
   */
  namespace?: string
  /**
   * List of file names that are considered meaningless for component naming purposes.
   *
   * When the `fileName` option is enabled and a component is in a file with a name
   * from this list, the directory name will be used instead of the file name for
   * the component's display name.
   *
   * @default `["index"]`
   */
  meaninglessFileNames?: Array<string>
  /**
   * Import paths to be considered as styled-components imports at the top level.
   *
   * **Note: This feature is not yet implemented in oxc.**
   */
  topLevelImportPaths?: Array<string>
}

/**
 * Transpile a JavaScript or TypeScript into a target ECMAScript version, asynchronously.
 *
 * Note: This function can be slower than `transform` due to the overhead of spawning a thread.
 *
 * @param filename The name of the file being transformed. If this is a
 * relative path, consider setting the {@link TransformOptions#cwd} option.
 * @param sourceText the source code itself
 * @param options The options for the transformation. See {@link
 * TransformOptions} for more information.
 *
 * @returns a promise that resolves to an object containing the transformed code,
 * source maps, and any errors that occurred during parsing or transformation.
 */
export declare function transform(filename: string, sourceText: string, options?: TransformOptions | undefined | null): Promise<TransformResult>

/**
 * Options for transforming a JavaScript or TypeScript file.
 *
 * Options are listed in evaluation order: the source is parsed (`lang`,
 * `sourceType`), declarations are emitted (`typescript.declaration`), then
 * transforms run (`typescript`, `decorator`, `plugins`,
 * `jsx`, `target`), followed by the `inject` and `define` plugins, and
 * finally codegen (`sourcemap`). `helpers` configures the runtime helpers
 * the transforms emit.
 *
 * @see {@link transform}
 */
export interface TransformOptions {
  /** Treat the source text as `js`, `jsx`, `ts`, `tsx`, or `dts`. */
  lang?: 'js' | 'jsx' | 'ts' | 'tsx' | 'dts'
  /** Treat the source text as `script` or `module` code. */
  sourceType?: 'script' | 'module' | 'commonjs' | 'unambiguous' | undefined
  /**
   * The current working directory. Used to resolve relative paths in other
   * options.
   */
  cwd?: string
  /** Set assumptions in order to produce smaller output. */
  assumptions?: CompilerAssumptions
  /**
   * Configure how TypeScript is transformed.
   *
   * `typescript.declaration` is evaluated before all transforms.
   *
   * @see {@link https://oxc.rs/docs/guide/usage/transformer/typescript}
   */
  typescript?: TypeScriptOptions
  /** Decorator plugin */
  decorator?: DecoratorOptions
  /**
   * Third-party plugins to use.
   * @see {@link https://oxc.rs/docs/guide/usage/transformer/plugins}
   */
  plugins?: PluginsOptions
  /**
   * Configure how TSX and JSX are transformed.
   * @see {@link https://oxc.rs/docs/guide/usage/transformer/jsx}
   */
  jsx?: 'preserve' | JsxOptions
  /**
   * Sets the target environment for the generated JavaScript.
   *
   * The lowest target is `es2015`.
   *
   * Example:
   *
   * * `'es2015'`
   * * `['es2020', 'chrome58', 'edge16', 'firefox57', 'node12', 'safari11']`
   *
   * @default `esnext` (No transformation)
   *
   * @see {@link https://oxc.rs/docs/guide/usage/transformer/lowering#target}
   */
  target?: string | Array<string>
  /** Behaviour for runtime helpers. */
  helpers?: Helpers
  /**
   * Inject Plugin
   *
   * Runs after all transforms.
   *
   * @see {@link https://oxc.rs/docs/guide/usage/transformer/global-variable-replacement#inject}
   */
  inject?: Record<string, string | [string, string]>
  /**
   * Define Plugin
   *
   * Runs after the inject plugin.
   *
   * @see {@link https://oxc.rs/docs/guide/usage/transformer/global-variable-replacement#define}
   */
  define?: Record<string, string>
  /**
   * Enable source map generation.
   *
   * When `true`, the `sourceMap` field of transform result objects will be populated.
   *
   * @default false
   *
   * @see {@link SourceMap}
   */
  sourcemap?: boolean
}

export interface TransformResult {
  /**
   * The transformed code.
   *
   * If parsing failed, this will be an empty string.
   */
  code: string
  /**
   * The source map for the transformed code.
   *
   * This will be set if {@link TransformOptions#sourcemap} is `true`.
   */
  map?: SourceMap
  /**
   * The `.d.ts` declaration file for the transformed code. Declarations are
   * only generated if `declaration` is set to `true` and a TypeScript file
   * is provided.
   *
   * If parsing failed and `declaration` is set, this will be an empty string.
   *
   * @see {@link TypeScriptOptions#declaration}
   * @see [declaration tsconfig option](https://www.typescriptlang.org/tsconfig/#declaration)
   */
  declaration?: string
  /**
   * Declaration source map. Only generated if both
   * {@link TypeScriptOptions#declaration declaration} and
   * {@link TransformOptions#sourcemap sourcemap} are set to `true`.
   */
  declarationMap?: SourceMap
  /**
   * Helpers used.
   *
   * @internal
   *
   * Example:
   *
   * ```text
   * { "_objectSpread": "@oxc-project/runtime/helpers/objectSpread2" }
   * ```
   */
  helpersUsed: Record<string, string>
  /**
   * Parse and transformation errors.
   *
   * Oxc's parser recovers from common syntax errors, meaning that
   * transformed code may still be available even if there are errors in this
   * list.
   */
  errors: Array<OxcError>
}

/**
 * Transpile a JavaScript or TypeScript into a target ECMAScript version.
 *
 * @param filename The name of the file being transformed. If this is a
 * relative path, consider setting the {@link TransformOptions#cwd} option..
 * @param sourceText the source code itself
 * @param options The options for the transformation. See {@link
 * TransformOptions} for more information.
 *
 * @returns an object containing the transformed code, source maps, and any
 * errors that occurred during parsing or transformation.
 */
export declare function transformSync(filename: string, sourceText: string, options?: TransformOptions | undefined | null): TransformResult

export interface TypeScriptOptions {
  jsxPragma?: string
  jsxPragmaFrag?: string
  onlyRemoveTypeImports?: boolean
  allowNamespaces?: boolean
  /**
   * When enabled, type-only class fields are only removed if they are prefixed with the declare modifier:
   *
   * @deprecated
   *
   * Allowing `declare` fields is built-in support in Oxc without any option. If you want to remove class fields
   * without initializer, you can use `remove_class_fields_without_initializer: true` instead.
   */
  allowDeclareFields?: boolean
  /**
   * When enabled, class fields without initializers are removed.
   *
   * For example:
   * ```ts
   * class Foo {
   *    x: number;
   *    y: number = 0;
   * }
   * ```
   * // transform into
   * ```js
   * class Foo {
   *    x: number;
   * }
   * ```
   *
   * The option is used to align with the behavior of TypeScript's `useDefineForClassFields: false` option.
   * When you want to enable this, you also need to set [`crate::CompilerAssumptions::set_public_class_fields`]
   * to `true`. The `set_public_class_fields: true` + `remove_class_fields_without_initializer: true` is
   * equivalent to `useDefineForClassFields: false` in TypeScript.
   *
   * When `set_public_class_fields` is true and class-properties plugin is enabled, the above example transforms into:
   *
   * ```js
   * class Foo {
   *   constructor() {
   *     this.y = 0;
   *   }
   * }
   * ```
   *
   * Defaults to `false`.
   */
  removeClassFieldsWithoutInitializer?: boolean
  /**
   * When true, optimize const enums by inlining their values at usage sites
   * and removing the enum declaration.
   *
   * @default false
   */
  optimizeConstEnums?: boolean
  /**
   * When true, optimize regular (non-const) enums by inlining their member
   * accesses at usage sites when the member value is statically known.
   *
   * Non-exported enum declarations are also removed when all members are
   * evaluable and no references to the enum as a runtime value exist
   * (e.g., `console.log(Foo)`, `typeof Foo`, or passing the enum as an argument).
   *
   * @default false
   */
  optimizeEnums?: boolean
  /**
   * Also generate a `.d.ts` declaration file for TypeScript files.
   *
   * The source file must be compliant with all
   * [`isolatedDeclarations`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-5.html#isolated-declarations)
   * requirements.
   *
   * @default false
   */
  declaration?: IsolatedDeclarationsOptions
  /**
   * Rewrite or remove TypeScript import/export declaration extensions.
   *
   * - When set to `rewrite`, it will change `.ts`, `.mts`, `.cts` extensions to `.js`, `.mjs`, `.cjs` respectively.
   * - When set to `remove`, it will remove `.ts`/`.mts`/`.cts`/`.tsx` extension entirely.
   * - When set to `true`, it's equivalent to `rewrite`.
   * - When set to `false` or omitted, no changes will be made to the extensions.
   *
   * @default false
   */
  rewriteImportExtensions?: 'rewrite' | 'remove' | boolean
}
export declare class BindingBundleEndEventData {
  output: string
  duration: number
  get result(): BindingWatcherBundler
}

export declare class BindingBundleErrorEventData {
  get result(): BindingWatcherBundler
  get error(): Array<BindingError>
}

export declare class BindingBundler {
  constructor()
  generate(options: BindingBundlerOptions): Promise<BindingResult<BindingOutputs>>
  write(options: BindingBundlerOptions): Promise<BindingResult<BindingOutputs>>
  scan(options: BindingBundlerOptions): Promise<BindingResult<undefined>>
  close(): Promise<undefined>
  get closed(): boolean
  getWatchFiles(): Array<string>
}

export declare class BindingCallableBuiltinPlugin {
  constructor(plugin: BindingBuiltinPlugin)
  getOrder(hookName: string): string | null
  resolveId(id: string, importer?: string | undefined | null, options?: BindingHookJsResolveIdOptions | undefined | null): Promise<BindingHookJsResolveIdOutput | undefined | null>
  load(id: string): Promise<BindingHookJsLoadOutput | undefined | null>
  transform(code: string, id: string, options: BindingTransformHookExtraArgs): Promise<BindingHookTransformOutput | undefined | null>
  watchChange(path: string, event: BindingJsWatchChangeEvent): Promise<undefined>
}

export declare class BindingChunkingContext {
  getModuleInfo(moduleId: string): BindingModuleInfo | null
}

/** A decoded source map with mappings as an array of arrays instead of VLQ-encoded string. */
export declare class BindingDecodedMap {
  /** The source map version (always 3). */
  get version(): number
  /** The generated file name. */
  get file(): string | null
  /** The list of original source files. */
  get sources(): Array<string>
  /** The original source contents (if `includeContent` was true). */
  get sourcesContent(): Array<string | undefined | null>
  /** The list of symbol names used in mappings. */
  get names(): Array<string>
  /**
   * The decoded mappings as an array of line arrays.
   * Each line is an array of segments, where each segment is [generatedColumn, sourceIndex, originalLine, originalColumn, nameIndex?].
   */
  get mappings(): Array<Array<Array<number>>>
  /** The list of source indices that should be excluded from debugging. */
  get x_google_ignoreList(): Array<number> | null
}

export declare class BindingDevEngine {
  constructor(options: BindingBundlerOptions, devOptions?: BindingDevOptions | undefined | null)
  run(): Promise<void>
  ensureCurrentBuildFinish(): Promise<void>
  getBundleState(): Promise<BindingBundleState>
  ensureLatestBuildOutput(): Promise<BindingResult<undefined>>
  triggerFullBuild(): void
  /**
   * Client-connect signal (the clientId hello): creates the per-client session
   * with an empty ship map. Reconnects arrive as fresh clientIds.
   */
  registerClient(clientId: string): Promise<void>
  /**
   * Delivery notification from the serving middleware: the response for
   * `filename` completed, so record its modules as shipped to that client.
   */
  notifyPayloadDelivered(filename: string): Promise<void>
  removeClient(clientId: string): Promise<void>
  close(): Promise<void>
  /**
   * Compile a lazy entry module and return HMR-style patch code.
   *
   * This is called when a dynamically imported module is first requested at runtime.
   * The module was previously stubbed with a proxy, and now we need to compile the
   * actual module and its dependencies.
   */
  compileEntry(moduleId: string, clientId: string): Promise<BindingLazyChunkOutput>
}

export declare class BindingLoadPluginContext {
  inner(): BindingPluginContext
  addWatchFile(file: string): void
}

export declare class BindingMagicString {
  constructor(source: string, options?: BindingMagicStringOptions | undefined | null)
  get original(): string
  get filename(): string | null
  get indentExclusionRanges(): Array<Array<number>> | Array<number> | null
  get ignoreList(): boolean
  get offset(): number
  set offset(offset: number)
  replace(from: string, to: string): this
  replaceAll(from: string, to: string): this
  /**
   * Returns the UTF-16 offset past the last match, or -1 if no match was found.
   * The JS wrapper uses this to update `lastIndex` on the caller's RegExp.
   * Global/sticky behavior is derived from the regex's own flags.
   */
  replaceRegex(from: RegExp, to: string): number
  prepend(content: string): this
  append(content: string): this
  prependLeft(index: number, content: string): this
  prependRight(index: number, content: string): this
  appendLeft(index: number, content: string): this
  appendRight(index: number, content: string): this
  overwrite(start: number, end: number, content: string, options?: BindingOverwriteOptions | undefined | null): this
  toString(): string
  hasChanged(): boolean
  length(): number
  isEmpty(): boolean
  remove(start: number, end: number): this
  update(start: number, end: number, content: string, options?: BindingUpdateOptions | undefined | null): this
  relocate(start: number, end: number, to: number): this
  /**
   * Alias for `relocate` to match the original magic-string API.
   * Moves the characters from `start` to `end` to `index`.
   * Returns `this` for method chaining.
   */
  move(start: number, end: number, index: number): this
  indent(indentor?: string | undefined | null, options?: BindingIndentOptions | undefined | null): this
  /** Trims whitespace or specified characters from the start and end. */
  trim(charType?: string | undefined | null): this
  /** Trims whitespace or specified characters from the start. */
  trimStart(charType?: string | undefined | null): this
  /** Trims whitespace or specified characters from the end. */
  trimEnd(charType?: string | undefined | null): this
  /** Trims newlines from the start and end. */
  trimLines(): this
  /**
   * Deprecated method that throws an error directing users to use prependRight or appendLeft.
   * This matches the original magic-string API which deprecated this method.
   */
  insert(index: number, content: string): void
  /** Returns a clone of the MagicString instance. */
  clone(): BindingMagicString
  /** Returns the last character of the generated string, or an empty string if empty. */
  lastChar(): string
  /** Returns the content after the last newline in the generated string. */
  lastLine(): string
  /** Returns the guessed indentation string, or `\t` if none is found. */
  getIndentString(): string
  /** Returns a clone with content outside the specified range removed. */
  snip(start: number, end: number): BindingMagicString
  /**
   * Resets the portion of the string from `start` to `end` to its original content.
   * This undoes any modifications made to that range.
   * Supports negative indices (counting from the end).
   */
  reset(start: number, end: number): this
  /**
   * Returns the content between the specified UTF-16 code unit positions (JS string indices).
   * Supports negative indices (counting from the end).
   *
   * When an index falls in the middle of a surrogate pair, the lone surrogate is
   * included in the result (matching the original magic-string / JS behavior).
   * This is done by returning a UTF-16 encoded JS string via `napi_create_string_utf16`.
   */
  slice(start?: number | undefined | null, end?: number | undefined | null): string
  /**
   * Generates a source map for the transformations applied to this MagicString.
   * Returns a BindingSourceMap object with version, file, sources, sourcesContent, names, mappings.
   */
  generateMap(options?: BindingSourceMapOptions | undefined | null): BindingSourceMap
  /**
   * Generates a decoded source map for the transformations applied to this MagicString.
   * Returns a BindingDecodedMap object with mappings as an array of arrays.
   */
  generateDecodedMap(options?: BindingSourceMapOptions | undefined | null): BindingDecodedMap
}

export declare class BindingModuleInfo {
  id: string
  importers: Array<string>
  dynamicImporters: Array<string>
  importedIds: Array<string>
  dynamicallyImportedIds: Array<string>
  exports: Array<string>
  isEntry: boolean
  inputFormat: 'es' | 'cjs' | 'unknown'
  get code(): string | null
}

export declare class BindingNormalizedOptions {
  get input(): Array<string> | Record<string, string>
  get cwd(): string
  get platform(): 'node' | 'browser' | 'neutral'
  get shimMissingExports(): boolean
  get name(): string | null
  get entryFilenames(): string | undefined
  get chunkFilenames(): string | undefined
  get sourcemapFilenames(): string | undefined
  get assetFilenames(): string | undefined
  get dir(): string | null
  get file(): string | null
  get format(): 'es' | 'cjs' | 'iife' | 'umd'
  get exports(): 'default' | 'named' | 'none' | 'auto'
  get esModule(): boolean | 'if-default-prop'
  get codeSplitting(): boolean
  get dynamicImportInCjs(): boolean
  get sourcemap(): boolean | 'inline' | 'hidden'
  get sourcemapBaseUrl(): string | null
  get banner(): string | undefined | null | undefined
  get footer(): string | undefined | null | undefined
  get intro(): string | undefined | null | undefined
  get outro(): string | undefined | null | undefined
  get postBanner(): string | undefined | null | undefined
  get postFooter(): string | undefined | null | undefined
  get externalLiveBindings(): boolean
  get extend(): boolean
  get globals(): Record<string, string> | undefined
  get hashCharacters(): 'base64' | 'base36' | 'hex'
  get sourcemapDebugIds(): boolean
  get sourcemapExcludeSources(): boolean
  get polyfillRequire(): boolean
  get minify(): false | 'dce-only' | MinifyOptions
  get legalComments(): 'none' | 'inline'
  get comments(): BindingCommentsOptions
  get preserveModules(): boolean
  get preserveModulesRoot(): string | undefined
  get virtualDirname(): string
  get topLevelVar(): boolean
  get minifyInternalExports(): boolean
  get context(): string
}

export declare class BindingOutputAsset {
  dropInner(): ExternalMemoryStatus
  getFileName(): string
  getOriginalFileName(): string | null
  getOriginalFileNames(): Array<string>
  getSource(): BindingAssetSource
  getName(): string | null
  getNames(): Array<string>
}

export declare class BindingOutputChunk {
  dropInner(): ExternalMemoryStatus
  getIsEntry(): boolean
  getIsDynamicEntry(): boolean
  getFacadeModuleId(): string | null
  getModuleIds(): Array<string>
  getExports(): Array<string>
  getFileName(): string
  getModules(): BindingModules
  getImports(): Array<string>
  getDynamicImports(): Array<string>
  getCode(): string
  getMap(): string | null
  getSourcemapFileName(): string | null
  getPreliminaryFileName(): string
  getName(): string
}

export declare class BindingPluginContext {
  load(specifier: string, sideEffects: boolean | 'no-treeshake' | undefined, packageJsonPath?: string): Promise<void>
  resolve(specifier: string, importer?: string | undefined | null, extraOptions?: BindingPluginContextResolveOptions | undefined | null): Promise<BindingPluginContextResolvedId | null>
  emitFile(file: BindingEmittedAsset, assetFilename?: string | undefined | null, fnSanitizedFileName?: string | undefined | null): string
  emitChunk(file: BindingEmittedChunk): string
  emitPrebuiltChunk(file: BindingEmittedPrebuiltChunk): string
  getFileName(referenceId: string): string
  getModuleInfo(moduleId: string): BindingModuleInfo | null
  getModuleIds(): Array<string>
  addWatchFile(file: string): void
}

export declare class BindingRenderedChunk {
  get name(): string
  get isEntry(): boolean
  get isDynamicEntry(): boolean
  get facadeModuleId(): string | null
  get moduleIds(): Array<string>
  get exports(): Array<string>
  get fileName(): string
  get modules(): BindingModules
  get imports(): Array<string>
  get dynamicImports(): Array<string>
}

export declare class BindingRenderedChunkMeta {
  get chunks(): Record<string, BindingRenderedChunk>
}

export declare class BindingRenderedModule {
  get code(): string | null
  get renderedExports(): Array<string>
}

/** A source map object with properties matching the SourceMap V3 specification. */
export declare class BindingSourceMap {
  /** The source map version (always 3). */
  get version(): number
  /** The generated file name. */
  get file(): string | null
  /** The list of original source files. */
  get sources(): Array<string>
  /** The original source contents (if `includeContent` was true). */
  get sourcesContent(): Array<string | undefined | null>
  /** The list of symbol names used in mappings. */
  get names(): Array<string>
  /** The VLQ-encoded mappings string. */
  get mappings(): string
  /** The list of source indices that should be excluded from debugging. */
  get x_google_ignoreList(): Array<number> | null
  /** Returns the source map as a JSON string. */
  toString(): string
  /** Returns the source map as a base64-encoded data URL. */
  toUrl(): string
}

export declare class BindingTransformPluginContext {
  getCombinedSourcemap(): string
  inner(): BindingPluginContext
  addWatchFile(file: string): void
  sendMagicString(magicString: BindingMagicString): string | null
}

export declare class BindingWatcher {
  constructor(options: BindingBundlerOptions[], listener: (data: BindingWatcherEvent) => void)
  run(): Promise<void>
  /**
   * Gives consumers a reliable way to await the watcher's completion.
   * The Node.js layer relies on the pending Promise to keep the process from exiting.
   */
  waitForClose(): Promise<void>
  close(): Promise<void>
}

/**
 * Minimal wrapper around a `BundleHandle` for watcher events.
 * This is returned from watcher event data to allow calling `result.close()`.
 */
export declare class BindingWatcherBundler {
  close(): Promise<void>
}

export declare class BindingWatcherChangeData {
  path: string
  kind: string
}

export declare class BindingWatcherEvent {
  eventKind(): string
  bundleEventKind(): string
  bundleEndData(): BindingBundleEndEventData
  bundleErrorData(): BindingBundleErrorEventData
  watchChangeData(): BindingWatcherChangeData
}

export declare class ParallelJsPluginRegistry {
  id: number
  workerCount: number
  constructor(workerCount: number)
}

export declare class TraceSubscriberGuard {
  close(): void
}

export declare class TsconfigCache {
  /** Create a new transform cache with auto tsconfig discovery enabled. */
  constructor(yarnPnp: boolean)
  /**
   * Clear the cache.
   *
   * Call this when tsconfig files have changed to ensure fresh resolution.
   */
  clear(): void
  /** Get the number of cached entries. */
  size(): number
}

export interface AliasItem {
  find: string
  replacements: Array<string | undefined | null>
}

export interface BindingAssetSource {
  inner: string | Uint8Array
}

export declare enum BindingAttachDebugInfo {
  None = 0,
  Simple = 1,
  Full = 2
}

export interface BindingBuiltinPlugin {
  __name: BindingBuiltinPluginName
  options?: unknown
}

export type BindingBuiltinPluginName =  'builtin:bundle-analyzer'|
'builtin:esm-external-require'|
'builtin:isolated-declaration'|
'builtin:replace'|
'builtin:vite-alias'|
'builtin:vite-build-import-analysis'|
'builtin:vite-dynamic-import-vars'|
'builtin:vite-import-glob'|
'builtin:vite-json'|
'builtin:vite-load-fallback'|
'builtin:vite-manifest'|
'builtin:vite-module-preload-polyfill'|
'builtin:vite-react-refresh-wrapper'|
'builtin:vite-reporter'|
'builtin:vite-resolve'|
'builtin:vite-transform'|
'builtin:vite-web-worker-post'|
'builtin:oxc-runtime';

export interface BindingBundleAnalyzerPluginConfig {
  /** Output filename for the bundle analysis data (default: "analyze-data.json") */
  fileName?: string
  /** Output format: "json" (default) or "md" for LLM-friendly markdown */
  format?: 'json' | 'md'
}

export interface BindingBundlerOptions {
  inputOptions: BindingInputOptions
  outputOptions: BindingOutputOptions
  parallelPluginsRegistry?: ParallelJsPluginRegistry
}

export interface BindingBundleState {
  lastBuildErrored: boolean
  /**
   * The stage of the last incremental failure, when `last_build_errored`
   * is true and the engine is in an incremental-failure state. Absent on
   * success and for an initial full-build failure (use
   * `last_build_errored` to detect that). The consumer can force a full
   * rebuild on the next page load when this is `Hmr`. See
   * `internal-docs/dev-engine/implementation.md` §12.
   */
  lastErrorStage?: BindingErrorStage
  hasStaleOutput: boolean
}

export interface BindingChecksOptions {
  circularDependency?: boolean
  eval?: boolean
  missingGlobalName?: boolean
  missingNameOptionForIifeExport?: boolean
  invalidAnnotation?: boolean
  mixedExports?: boolean
  unresolvedEntry?: boolean
  unresolvedImport?: boolean
  filenameConflict?: boolean
  commonJsVariableInEsm?: boolean
  importIsUndefined?: boolean
  emptyImportMeta?: boolean
  toleratedTransform?: boolean
  cannotCallNamespace?: boolean
  configurationFieldConflict?: boolean
  preferBuiltinFeature?: boolean
  couldNotCleanDirectory?: boolean
  pluginTimings?: boolean
  duplicateShebang?: boolean
  unsupportedTsconfigOption?: boolean
  ineffectiveDynamicImport?: boolean
  largeBarrelModules?: boolean
  sourcemapBroken?: boolean
}

export interface BindingChunkImportMap {
  baseUrl?: string
  fileName?: string
}

export declare enum BindingChunkModuleOrderBy {
  ModuleId = 0,
  ExecOrder = 1
}

export interface BindingChunkOptimizationOptions {
  mergeCommonChunks?: boolean
  avoidRedundantChunkLoads?: boolean
}

export interface BindingClientHmrUpdate {
  clientId: string
  update: BindingHmrUpdate
}

export interface BindingCommentsOptions {
  legal?: boolean
  annotation?: boolean
  jsdoc?: boolean
}

export interface BindingCompilerOptions {
  baseUrl?: string
  paths?: Record<string, Array<string>>
  experimentalDecorators?: boolean
  emitDecoratorMetadata?: boolean
  useDefineForClassFields?: boolean
  rewriteRelativeImportExtensions?: boolean
  jsx?: string
  jsxFactory?: string
  jsxFragmentFactory?: string
  jsxImportSource?: string
  verbatimModuleSyntax?: boolean
  preserveValueImports?: boolean
  importsNotUsedAsValues?: string
  target?: string
  module?: string
  allowJs?: boolean
  rootDirs?: Array<string>
}

export interface BindingDeferSyncScanData {
  /** ModuleId */
  id: string
  sideEffects?: boolean | 'no-treeshake'
}

export interface BindingDevOptions {
  onHmrUpdates?: undefined | ((result: BindingResult<[BindingClientHmrUpdate[], string[]]>) => void | Promise<void>)
  onOutput?: undefined | ((result: BindingResult<BindingOutputs>) => void | Promise<void>)
  /**
   * Called with assets emitted while generating an HMR patch or compiling a
   * lazy entry. These never go through `on_output`, so a consumer (e.g. Vite)
   * must register this to serve them (e.g. write them to its in-memory files).
   */
  onAdditionalAssets?: undefined | ((output: BindingOutputs) => void | Promise<void>)
  rebuildStrategy?: BindingRebuildStrategy
  watch?: BindingDevWatchOptions
}

export interface BindingDevtoolsOptions {
  sessionId?: string
}

export interface BindingDevWatchOptions {
  enabled?: boolean
  skipWrite?: boolean
  usePolling?: boolean
  pollInterval?: number
  useDebounce?: boolean
  debounceDuration?: number
  compareContentsForPolling?: boolean
  debounceTickRate?: number
  include?: Array<BindingStringOrRegex>
  exclude?: Array<BindingStringOrRegex>
}

export interface BindingEmittedAsset {
  name?: string
  fileName?: string
  originalFileName?: string
  source: BindingAssetSource
}

export interface BindingEmittedChunk {
  name?: string
  fileName?: string
  id: string
  importer?: string
  preserveEntrySignatures?: BindingPreserveEntrySignatures
}

export interface BindingEmittedPrebuiltChunk {
  fileName: string
  name?: string
  code: string
  exports?: Array<string>
  map?: BindingSourcemap
  sourcemapFileName?: string
  facadeModuleId?: string
  isEntry?: boolean
  isDynamicEntry?: boolean
}

/** Enhanced transform options with tsconfig and inputMap support. */
export interface BindingEnhancedTransformOptions {
  /** Treat the source text as 'js', 'jsx', 'ts', 'tsx', or 'dts'. */
  lang?: 'js' | 'jsx' | 'ts' | 'tsx' | 'dts'
  /** Treat the source text as 'script', 'module', 'commonjs', or 'unambiguous'. */
  sourceType?: 'script' | 'module' | 'commonjs' | 'unambiguous' | undefined
  /**
   * The current working directory. Used to resolve relative paths in other
   * options.
   */
  cwd?: string
  /**
   * Enable source map generation.
   *
   * When `true`, the `sourceMap` field of transform result objects will be populated.
   *
   * @default false
   */
  sourcemap?: boolean
  /** Set assumptions in order to produce smaller output. */
  assumptions?: CompilerAssumptions
  /**
   * Configure how TypeScript is transformed.
   * @see {@link https://oxc.rs/docs/guide/usage/transformer/typescript}
   */
  typescript?: TypeScriptOptions
  /**
   * Configure how TSX and JSX are transformed.
   * @see {@link https://oxc.rs/docs/guide/usage/transformer/jsx}
   */
  jsx?: 'preserve' | JsxOptions
  /**
   * Sets the target environment for the generated JavaScript.
   *
   * The lowest target is `es2015`.
   *
   * Example:
   *
   * * `'es2015'`
   * * `['es2020', 'chrome58', 'edge16', 'firefox57', 'node12', 'safari11']`
   *
   * @default `esnext` (No transformation)
   *
   * @see {@link https://oxc.rs/docs/guide/usage/transformer/lowering#target}
   */
  target?: string | Array<string>
  /** Behaviour for runtime helpers. */
  helpers?: Helpers
  /**
   * Define Plugin
   * @see {@link https://oxc.rs/docs/guide/usage/transformer/global-variable-replacement#define}
   */
  define?: Record<string, string>
  /**
   * Inject Plugin
   * @see {@link https://oxc.rs/docs/guide/usage/transformer/global-variable-replacement#inject}
   */
  inject?: Record<string, string | [string, string]>
  /** Decorator plugin */
  decorator?: DecoratorOptions
  /**
   * Third-party plugins to use.
   * @see {@link https://oxc.rs/docs/guide/usage/transformer/plugins}
   */
  plugins?: PluginsOptions
  /**
   * Configure tsconfig handling.
   * - true: Auto-discover and load the nearest tsconfig.json
   * - TsconfigRawOptions: Use the provided inline tsconfig options
   */
  tsconfig?: boolean | BindingTsconfigRawOptions
  /** An input source map to collapse with the output source map. */
  inputMap?: SourceMap
}

/** Result of the enhanced transform API. */
export interface BindingEnhancedTransformResult {
  /**
   * The transformed code.
   *
   * If parsing failed, this will be an empty string.
   */
  code: string
  /**
   * The source map for the transformed code.
   *
   * This will be set if {@link BindingEnhancedTransformOptions#sourcemap} is `true`.
   */
  map?: SourceMap
  /**
   * The `.d.ts` declaration file for the transformed code. Declarations are
   * only generated if `declaration` is set to `true` and a TypeScript file
   * is provided.
   *
   * If parsing failed and `declaration` is set, this will be an empty string.
   *
   * @see {@link TypeScriptOptions#declaration}
   * @see [declaration tsconfig option](https://www.typescriptlang.org/tsconfig/#declaration)
   */
  declaration?: string
  /**
   * Declaration source map. Only generated if both
   * {@link TypeScriptOptions#declaration declaration} and
   * {@link BindingEnhancedTransformOptions#sourcemap sourcemap} are set to `true`.
   */
  declarationMap?: SourceMap
  /**
   * Helpers used.
   *
   * @internal
   *
   * Example:
   *
   * ```text
   * { "_objectSpread": "@oxc-project/runtime/helpers/objectSpread2" }
   * ```
   */
  helpersUsed: Record<string, string>
  /** Parse and transformation errors. */
  errors: Array<BindingError>
  /** Parse and transformation warnings. */
  warnings: Array<BindingError>
  /** Paths to tsconfig files that were loaded during transformation. */
  tsconfigFilePaths: Array<string>
}

export type BindingError =
  | { type: 'JsError', field0: Error }
  | { type: 'NativeError', field0: NativeError }

export interface BindingErrors {
  errors: Array<BindingError>
  isBindingErrors: boolean
}

/**
 * Which stage of an incremental dev build produced the last error.
 *
 * Mirrors `rolldown_dev::ErrorStage`. Surfaced on
 * [`crate::binding_dev_engine::BindingBundleState`] so the consumer can
 * treat an `Hmr`-stage failure as recoverable by forcing a full rebuild
 * on the next page load (HMR generation may itself be buggy). See
 * `internal-docs/dev-engine/implementation.md` §12.
 */
export type BindingErrorStage =  'Hmr'|
'Rebuild';

export interface BindingEsmExternalRequirePluginConfig {
  external: Array<BindingStringOrRegex>
  skipDuplicateCheck?: boolean
}

export interface BindingExperimentalDevModeOptions {
  host?: string
  port?: number
  implement: string
  /** @deprecated Common runtime injection will be disabled by default in the future. */
  skipCommonRuntimeInjection?: boolean
  lazy?: boolean
}

export interface BindingExperimentalOptions {
  viteMode?: boolean
  resolveNewUrlToAsset?: boolean
  devMode?: BindingExperimentalDevModeOptions
  attachDebugInfo?: BindingAttachDebugInfo
  chunkModulesOrder?: BindingChunkModuleOrderBy
  chunkImportMap?: boolean | BindingChunkImportMap
  onDemandWrapping?: boolean
  incrementalBuild?: boolean
  nativeMagicString?: boolean
  chunkOptimization?: boolean | BindingChunkOptimizationOptions
  lazyBarrel?: boolean
}

export interface BindingFilterToken {
  kind: FilterTokenKind
  payload?: BindingStringOrRegex | number | boolean
}

export interface BindingGeneratedCodeOptions {
  symbols?: boolean
  preset?: string
}

export type BindingHmrUpdate =
  | { type: 'Patch', code: string, filename: string, sourcemap?: string, sourcemapFilename?: string, /**
   * Stable ids of the changed modules — the `changedIds` of the push envelope.
   * The client walks from these on its own graph.
   */
  changedIds: Array<string>, /** Per-client envelope sequence number. */
seq: number }
| { type: 'FullReload', reason?: string }
| { type: 'Noop' }

export interface BindingHookFilter {
  value?: Array<Array<BindingFilterToken>>
}

export interface BindingHookJsLoadOutput {
  code: string
  map?: string
  moduleSideEffects?: boolean | 'no-treeshake'
}

export interface BindingHookJsResolveIdOptions {
  isEntry?: boolean
  /**
   * - `import-statement`: `import { foo } from './lib.js';`
   * - `dynamic-import`: `import('./lib.js')`
   * - `require-call`: `require('./lib.js')`
   * - `import-rule`: `@import 'bg-color.css'`
   * - `url-token`: `url('./icon.png')`
   * - `new-url`: `new URL('./worker.js', import.meta.url)`
   * - `hot-accept`: `import.meta.hot.accept('./lib.js', () => {})`
   */
  kind?: 'import-statement' | 'dynamic-import' | 'require-call' | 'import-rule' | 'url-token' | 'new-url' | 'hot-accept'
  scan?: boolean
  custom?: BindingVitePluginCustom
}

export interface BindingHookJsResolveIdOutput {
  id: string
  external?: boolean | 'absolute' | 'relative'
  moduleSideEffects?: boolean | 'no-treeshake'
}

export interface BindingHookLoadOutput {
  code: string
  moduleSideEffects?: boolean | 'no-treeshake'
  map?: BindingSourcemap
  moduleType?: string
}

export interface BindingHookRenderChunkOutput {
  code: string
  /**
   * A sourcemap, or `null` to explicitly signal "no sourcemap" (distinct from
   * omitting the field, which mirrors Rollup's "possibly broken" semantics).
   */
  map?: BindingSourcemap | null
}

export interface BindingHookResolveFileUrlArgs {
  /** Preliminary filename of the chunk containing the reference. */
  chunkId: string
  /** Filename of the emitted file, relative to the output directory. */
  fileName: string
  format: 'es' | 'cjs' | 'iife' | 'umd'
  /** Id of the module containing the `import.meta.ROLLDOWN_FILE_URL_*` reference. */
  moduleId: string
  referenceId: string
  /** Path from the chunk to the emitted file. */
  relativePath: string
  /**
   * The `<urlId>` of `import.meta.ROLLDOWN_FILE_URL_<referenceId>_<urlId>`, if present.
   * Only the rolldown-specific form carries it; the `ROLLUP_FILE_URL_` alias never does.
   */
  urlId?: string
}

export interface BindingHookResolveIdExtraArgs {
  custom?: number
  isEntry: boolean
  /**
   * - `import-statement`: `import { foo } from './lib.js';`
   * - `dynamic-import`: `import('./lib.js')`
   * - `require-call`: `require('./lib.js')`
   * - `import-rule`: `@import 'bg-color.css'`
   * - `url-token`: `url('./icon.png')`
   * - `new-url`: `new URL('./worker.js', import.meta.url)`
   * - `hot-accept`: `import.meta.hot.accept('./lib.js', () => {})`
   */
  kind: 'import-statement' | 'dynamic-import' | 'require-call' | 'import-rule' | 'url-token' | 'new-url' | 'hot-accept'
}

export interface BindingHookResolveIdOutput {
  id: string
  external?: BindingResolvedExternal
  normalizeExternalId?: boolean
  moduleSideEffects?: boolean | 'no-treeshake'
  /**
   * @internal Used to store package json path resolved by oxc resolver,
   * we could get the related package json object via the path string.
   */
  packageJsonPath?: string | null
}

export type BindingHookSideEffects =
  boolean | string

export interface BindingHookTransformOutput {
  code?: string
  moduleSideEffects?: BindingHookSideEffects
  /**
   * A sourcemap, or `null` to explicitly signal "no sourcemap" (distinct from
   * omitting the field, which mirrors Rollup's "possibly broken" semantics).
   */
  map?: BindingSourcemap | null
  moduleType?: string
}

export interface BindingHotUpdateArgs {
  kind: 'create' | 'update' | 'delete'
  /** Normalized absolute path of the changed file. */
  file: string
  /** The affected module ids as currently computed (raw module ids). */
  modules: Array<string>
}

export interface BindingIndentOptions {
  exclude?: Array<Array<number>> | Array<number>
}

export type BindingInjectImport =
  BindingInjectImportNamed | BindingInjectImportNamespace

export interface BindingInjectImportNamed {
  tagNamed: true
  imported: string
  alias?: string
  from: string
}

export interface BindingInjectImportNamespace {
  tagNamespace: true
  alias: string
  from: string
}

export interface BindingInlineConstConfig {
  mode?: string
  pass?: number
}

export interface BindingInputItem {
  name?: string
  import: string
}

export interface BindingInputOptions {
  external?: Array<string | RegExp> | ((source: string, importer: string | undefined, isResolved: boolean) => boolean)
  input: Array<BindingInputItem>
  plugins: (BindingBuiltinPlugin | BindingPluginOptions | undefined)[]
  resolve?: BindingResolveOptions
  shimMissingExports?: boolean
  platform?: 'node' | 'browser' | 'neutral'
  logLevel: BindingLogLevel
  onLog: (logLevel: 'debug' | 'warn' | 'info', log: BindingLog) => void
  cwd: string
  treeshake?: BindingTreeshake
  moduleTypes?: Record<string, string>
  define?: Array<[string, string]>
  dropLabels?: Array<string>
  inject?: Array<BindingInjectImport>
  experimental?: BindingExperimentalOptions
  profilerNames?: boolean
  transform?: TransformOptions
  watch?: BindingWatchOption
  keepNames?: boolean
  checks?: BindingChecksOptions
  deferSyncScanData?: undefined | (() => BindingDeferSyncScanData[])
  makeAbsoluteExternalsRelative?: BindingMakeAbsoluteExternalsRelative
  devtools?: BindingDevtoolsOptions
  invalidateJsSideCache?: () => void
  preserveEntrySignatures?: BindingPreserveEntrySignatures
  optimization?: BindingOptimization
  context?: string
  tsconfig?: boolean | string
}

export interface BindingIsolatedDeclarationPluginConfig {
  stripInternal?: boolean
}

export interface BindingJsonSourcemap {
  file?: string
  mappings?: string
  sourceRoot?: string
  sources?: Array<string | undefined | null>
  sourcesContent?: Array<string | undefined | null>
  names?: Array<string>
  debugId?: string
  x_google_ignoreList?: Array<number>
}

export interface BindingJsWatchChangeEvent {
  event: string
}

/**
 * The client-facing slice of a lazy-compile result. The carried modules and
 * stamps stay server-side as the engine's pending-payload entry.
 */
export interface BindingLazyChunkOutput {
  code: string
  filename: string
  /**
   * The chunk's sourcemap, when `sourcemap` is `File` or `Hidden`. Serve it
   * under `sourcemapFilename`, which is what the chunk's `sourceMappingURL`
   * refers to.
   */
  sourcemap?: string
  sourcemapFilename?: string
}

export interface BindingLog {
  message: string
  id?: string
  code?: string
  exporter?: string
  plugin?: string
  /** Location information (line, column, file) */
  loc?: BindingLogLocation
  /** Position in the source file in UTF-16 code units */
  pos?: number
  /** List of module IDs (used for CIRCULAR_DEPENDENCY warnings) */
  ids?: Array<string>
}

export declare enum BindingLogLevel {
  Silent = 0,
  Warn = 1,
  Info = 2,
  Debug = 3
}

export interface BindingLogLocation {
  /** 1-based */
  line: number
  /** 0-based position in the line in UTF-16 code units */
  column: number
  file?: string
}

export interface BindingMagicStringOptions {
  filename?: string
  offset?: number
  indentExclusionRanges?: Array<Array<number>> | Array<number>
  ignoreList?: boolean
}

export type BindingMakeAbsoluteExternalsRelative =
  | { type: 'Bool', field0: boolean }
  | { type: 'IfRelativeSource' }

export interface BindingManualCodeSplittingOptions {
  includeDependenciesRecursively?: boolean
  minSize?: number
  minShareCount?: number
  groups?: Array<BindingMatchGroup>
  maxSize?: number
  minModuleSize?: number
  maxModuleSize?: number
}

export interface BindingMatchGroup {
  name: string | ((id: string, ctx: BindingChunkingContext) => VoidNullable<string>)
  test?: string | RegExp | ((id: string) => VoidNullable<boolean>)
  priority?: number
  minSize?: number
  minShareCount?: number
  minModuleSize?: number
  maxModuleSize?: number
  maxSize?: number
  entriesAware?: boolean
  entriesAwareMergeThreshold?: number
  tags?: Array<string>
  includeDependenciesRecursively?: boolean
}

export interface BindingModules {
  values: Array<BindingRenderedModule>
  keys: Array<string>
}

export interface BindingModuleSideEffectsRule {
  test?: RegExp | undefined
  sideEffects: boolean
  external?: boolean
}

export interface BindingOptimization {
  inlineConst?: boolean | BindingInlineConstConfig
  pifeForModuleWrappers?: boolean
}

export interface BindingOutputOptions {
  name?: string
  assetFileNames?: string | ((chunk: BindingPreRenderedAsset) => string)
  entryFileNames?: string | ((chunk: PreRenderedChunk) => string)
  chunkFileNames?: string | ((chunk: PreRenderedChunk) => string)
  sanitizeFileName?: boolean | ((name: string) => string)
  banner?: string | ((chunk: BindingRenderedChunk) => MaybePromise<VoidNullable<string>>)
  postBanner?: string | ((chunk: BindingRenderedChunk) => MaybePromise<VoidNullable<string>>)
  footer?: string | ((chunk: BindingRenderedChunk) => MaybePromise<VoidNullable<string>>)
  postFooter?: string | ((chunk: BindingRenderedChunk) => MaybePromise<VoidNullable<string>>)
  dir?: string
  file?: string
  esModule?: boolean | 'if-default-prop'
  exports?: 'default' | 'named' | 'none' | 'auto'
  extend?: boolean
  externalLiveBindings?: boolean
  format?: 'es' | 'cjs' | 'iife' | 'umd'
  generatedCode?: BindingGeneratedCodeOptions
  globals?: Record<string, string> | ((name: string) => string)
  hashCharacters?: 'base64' | 'base36' | 'hex'
  inlineDynamicImports?: boolean
  dynamicImportInCjs?: boolean
  intro?: string | ((chunk: BindingRenderedChunk) => MaybePromise<VoidNullable<string>>)
  outro?: string | ((chunk: BindingRenderedChunk) => MaybePromise<VoidNullable<string>>)
  paths?: Record<string, string> | ((id: string) => string)
  plugins: (BindingBuiltinPlugin | BindingPluginOptions | undefined)[]
  sourcemap?: 'file' | 'inline' | 'hidden'
  sourcemapFileNames?: string | ((chunk: PreRenderedChunk) => string)
  sourcemapBaseUrl?: string
  sourcemapIgnoreList?: boolean | string | RegExp | ((source: string, sourcemapPath: string) => boolean)
  sourcemapDebugIds?: boolean
  sourcemapPathTransform?: (source: string, sourcemapPath: string) => string
  sourcemapExcludeSources?: boolean
  strict?: boolean | 'auto'
  minify?: boolean | 'dce-only' | MinifyOptions
  manualCodeSplitting?: BindingManualCodeSplittingOptions
  legalComments?: 'none' | 'inline'
  comments?: boolean | BindingCommentsOptions
  polyfillRequire?: boolean
  preserveModules?: boolean
  virtualDirname?: string
  preserveModulesRoot?: string
  topLevelVar?: boolean
  minifyInternalExports?: boolean
  cleanDir?: boolean
  strictExecutionOrder?: boolean
}

export interface BindingOutputs {
  chunks: Array<BindingOutputChunk>
  assets: Array<BindingOutputAsset>
}

export interface BindingOverwriteOptions {
  contentOnly?: boolean
  /** Stores the replaced content in the generated sourcemap's `names` field. */
  storeName?: boolean
}

export interface BindingPluginContextResolvedId {
  id: string
  packageJsonPath?: string
  external: boolean | 'absolute' | 'relative'
  moduleSideEffects?: boolean | 'no-treeshake'
}

export interface BindingPluginContextResolveOptions {
  /**
   * - `import-statement`: `import { foo } from './lib.js';`
   * - `dynamic-import`: `import('./lib.js')`
   * - `require-call`: `require('./lib.js')`
   * - `import-rule`: `@import 'bg-color.css'`
   * - `url-token`: `url('./icon.png')`
   * - `new-url`: `new URL('./worker.js', import.meta.url)`
   * - `hot-accept`: `import.meta.hot.accept('./lib.js', () => {})`
   */
  importKind?: 'import-statement' | 'dynamic-import' | 'require-call' | 'import-rule' | 'url-token' | 'new-url' | 'hot-accept'
  isEntry?: boolean
  skipSelf?: boolean
  custom?: number
  vitePluginCustom?: BindingVitePluginCustom
}

export interface BindingPluginHookMeta {
  order?: BindingPluginOrder
}

export interface BindingPluginOptions {
  name: string
  hookUsage: number
  buildStart?: (ctx: BindingPluginContext, opts: BindingNormalizedOptions) => MaybePromise<VoidNullable>
  buildStartMeta?: BindingPluginHookMeta
  resolveId?: (ctx: BindingPluginContext, specifier: string, importer: Nullable<string>, options: BindingHookResolveIdExtraArgs) => MaybePromise<VoidNullable<BindingHookResolveIdOutput>>
  resolveIdMeta?: BindingPluginHookMeta
  resolveIdFilter?: BindingHookFilter
  resolveDynamicImport?: (ctx: BindingPluginContext, specifier: string, importer: Nullable<string>) => MaybePromise<VoidNullable<BindingHookResolveIdOutput>>
  resolveDynamicImportMeta?: BindingPluginHookMeta
  load?: (ctx: BindingLoadPluginContext, id: string) => MaybePromise<VoidNullable<BindingHookLoadOutput>>
  loadMeta?: BindingPluginHookMeta
  loadFilter?: BindingHookFilter
  transform?: (ctx:  BindingTransformPluginContext, id: string, code: string, module_type: BindingTransformHookExtraArgs) => MaybePromise<VoidNullable<BindingHookTransformOutput>>
  transformMeta?: BindingPluginHookMeta
  transformFilter?: BindingHookFilter
  moduleParsed?: (ctx: BindingPluginContext, module: BindingModuleInfo) => MaybePromise<VoidNullable>
  moduleParsedMeta?: BindingPluginHookMeta
  buildEnd?: (ctx: BindingPluginContext, error?: BindingError[]) => MaybePromise<VoidNullable>
  buildEndMeta?: BindingPluginHookMeta
  renderChunk?: (ctx: BindingPluginContext, code: string, chunk: BindingRenderedChunk, opts: BindingNormalizedOptions, meta: BindingRenderedChunkMeta) => MaybePromise<VoidNullable<BindingHookRenderChunkOutput>>
  renderChunkMeta?: BindingPluginHookMeta
  renderChunkFilter?: BindingHookFilter
  augmentChunkHash?: (ctx: BindingPluginContext, chunk: BindingRenderedChunk) => MaybePromise<void | string>
  augmentChunkHashMeta?: BindingPluginHookMeta
  resolveFileUrl?: (ctx: BindingPluginContext, args: BindingHookResolveFileUrlArgs) => MaybePromise<void | string | null>
  resolveFileUrlMeta?: BindingPluginHookMeta
  renderStart?: (ctx: BindingPluginContext, opts: BindingNormalizedOptions) => void
  renderStartMeta?: BindingPluginHookMeta
  renderError?: (ctx: BindingPluginContext, error: BindingError[]) => void
  renderErrorMeta?: BindingPluginHookMeta
  generateBundle?: (ctx: BindingPluginContext, bundle: BindingErrorsOr<BindingOutputs>, isWrite: boolean, opts: BindingNormalizedOptions) => MaybePromise<VoidNullable<JsChangedOutputs>>
  generateBundleMeta?: BindingPluginHookMeta
  writeBundle?: (ctx: BindingPluginContext, bundle: BindingErrorsOr<BindingOutputs>, opts: BindingNormalizedOptions) => MaybePromise<VoidNullable<JsChangedOutputs>>
  writeBundleMeta?: BindingPluginHookMeta
  closeBundle?: (ctx: BindingPluginContext, error?: BindingError[]) => MaybePromise<VoidNullable>
  closeBundleMeta?: BindingPluginHookMeta
  watchChange?: (ctx: BindingPluginContext, path: string, event: string) => MaybePromise<VoidNullable>
  watchChangeMeta?: BindingPluginHookMeta
  hotUpdate?: (ctx: BindingPluginContext, args: BindingHotUpdateArgs) => MaybePromise<VoidNullable<Array<string>>>
  hotUpdateMeta?: BindingPluginHookMeta
  closeWatcher?: (ctx: BindingPluginContext) => MaybePromise<VoidNullable>
  closeWatcherMeta?: BindingPluginHookMeta
  banner?: (ctx: BindingPluginContext, chunk: BindingRenderedChunk) => void
  bannerMeta?: BindingPluginHookMeta
  footer?: (ctx: BindingPluginContext, chunk: BindingRenderedChunk) => void
  footerMeta?: BindingPluginHookMeta
  intro?: (ctx: BindingPluginContext, chunk: BindingRenderedChunk) => void
  introMeta?: BindingPluginHookMeta
  outro?: (ctx: BindingPluginContext, chunk: BindingRenderedChunk) => void
  outroMeta?: BindingPluginHookMeta
}

export declare enum BindingPluginOrder {
  Pre = 0,
  Post = 1
}

export interface BindingPluginWithIndex {
  index: number
  plugin: BindingPluginOptions
}

export interface BindingPreRenderedAsset {
  name?: string
  names: Array<string>
  originalFileName?: string
  originalFileNames: Array<string>
  source: BindingAssetSource
}

export type BindingPreserveEntrySignatures =
  | { type: 'Bool', field0: boolean }
  | { type: 'String', field0: string }

export declare enum BindingPropertyReadSideEffects {
  Always = 0,
  False = 1
}

export declare enum BindingPropertyWriteSideEffects {
  Always = 0,
  False = 1
}

export declare enum BindingRebuildStrategy {
  Always = 0,
  Never = 1
}

export interface BindingReplacePluginConfig {
  values: Record<string, string>
  delimiters?: [string, string]
  preventAssignment?: boolean
  objectGuards?: boolean
  sourcemap?: boolean
}

export type BindingResolvedExternal =
  boolean | string

export interface BindingResolveOptions {
  alias?: Array<AliasItem>
  aliasFields?: Array<Array<string>>
  conditionNames?: Array<string>
  exportsFields?: Array<Array<string>>
  extensions?: Array<string>
  extensionAlias?: Array<ExtensionAliasItem>
  mainFields?: Array<string>
  mainFiles?: Array<string>
  modules?: Array<string>
  symlinks?: boolean
  yarnPnp?: boolean
}

export interface BindingSourcemap {
  inner: string | BindingJsonSourcemap
}

export interface BindingSourceMapOptions {
  /** The filename for the generated file (goes into `map.file`) */
  file?: string
  /** The filename of the original source (goes into `map.sources`) */
  source?: string
  includeContent?: boolean
  /**
   * Accepts boolean or string: true, false, "boundary"
   * - true: high-resolution sourcemaps (character-level)
   * - false: low-resolution sourcemaps (line-level) - default
   * - "boundary": high-resolution only at word boundaries
   */
  hires?: boolean | string
}

export interface BindingTransformHookExtraArgs {
  moduleType: string
}

export interface BindingTreeshake {
  moduleSideEffects: boolean | ReadonlyArray<string> | BindingModuleSideEffectsRule[] | ((id: string, external: boolean) => boolean | undefined)
  annotations?: boolean
  manualPureFunctions?: ReadonlyArray<string>
  unknownGlobalSideEffects?: boolean
  invalidImportSideEffects?: boolean
  commonjs?: boolean
  propertyReadSideEffects?: BindingPropertyReadSideEffects
  propertyWriteSideEffects?: BindingPropertyWriteSideEffects
}

export interface BindingTsconfig {
  files?: Array<string>
  include?: Array<string>
  exclude?: Array<string>
  compilerOptions: BindingCompilerOptions
}

/**
 * TypeScript compiler options for inline tsconfig configuration.
 *
 * @category Utilities
 */
export interface BindingTsconfigCompilerOptions {
  /** Specifies the JSX factory function to use. */
  jsx?: 'react' | 'react-jsx' | 'react-jsxdev' | 'preserve' | 'react-native'
  /** Specifies the JSX factory function. */
  jsxFactory?: string
  /** Specifies the JSX fragment factory function. */
  jsxFragmentFactory?: string
  /** Specifies the module specifier for JSX imports. */
  jsxImportSource?: string
  /** Enables experimental decorators. */
  experimentalDecorators?: boolean
  /** Enables decorator metadata emission. */
  emitDecoratorMetadata?: boolean
  /** Enables all strict type-checking options. Used as the fallback for `strictNullChecks`. */
  strict?: boolean
  /**
   * Enables strict null checks. Controls whether `null`/`undefined` are elided from
   * nullable-union `design:type` decorator metadata.
   */
  strictNullChecks?: boolean
  /** Preserves module structure of imports/exports. */
  verbatimModuleSyntax?: boolean
  /** Configures how class fields are emitted. */
  useDefineForClassFields?: boolean
  /** The ECMAScript target version. */
  target?: string
  /** @deprecated Use verbatimModuleSyntax instead. */
  preserveValueImports?: boolean
  /** @deprecated Use verbatimModuleSyntax instead. */
  importsNotUsedAsValues?: 'remove' | 'preserve' | 'error'
}

/**
 * Raw tsconfig options for inline configuration.
 *
 * @category Utilities
 */
export interface BindingTsconfigRawOptions {
  /** TypeScript compiler options. */
  compilerOptions?: BindingTsconfigCompilerOptions
}

export interface BindingTsconfigResult {
  tsconfig: BindingTsconfig
  tsconfigFilePaths: Array<string>
}

export interface BindingUpdateOptions {
  overwrite?: boolean
  /** Stores the replaced content in the generated sourcemap's `names` field. */
  storeName?: boolean
}

export interface BindingViteAliasPluginAlias {
  find: BindingStringOrRegex
  replacement: string
}

export interface BindingViteAliasPluginConfig {
  entries: Array<BindingViteAliasPluginAlias>
}

export interface BindingViteBuildImportAnalysisPluginConfig {
  preloadCode: string
  insertPreload: boolean
  optimizeModulePreloadRelativePaths: boolean
  renderBuiltUrl: boolean
  isRelativeBase: boolean
}

export interface BindingViteDynamicImportVarsPluginConfig {
  sourcemap?: boolean
  include?: Array<BindingStringOrRegex>
  exclude?: Array<BindingStringOrRegex>
  resolver?: (id: string, importer: string) => MaybePromise<string | undefined>
}

export interface BindingViteImportGlobPluginConfig {
  root?: string
  sourcemap?: boolean
  restoreQueryExtension?: boolean
}

export interface BindingViteJsonPluginConfig {
  minify?: boolean
  namedExports?: boolean
  stringify?: BindingViteJsonPluginStringify
}

export type BindingViteJsonPluginStringify =
  boolean | string

export interface BindingViteManifestPluginConfig {
  root: string
  outPath: string
  isLegacy?: (args: BindingNormalizedOptions) => boolean
  cssEntries: () => Record<string, string>
}

export interface BindingViteModulePreloadPolyfillPluginConfig {
  isServer?: boolean
}

export interface BindingVitePluginCustom {
  'vite:import-glob'?: ViteImportGlobMeta
}

export interface BindingViteReactRefreshWrapperPluginConfig {
  cwd: string
  include?: Array<BindingStringOrRegex>
  exclude?: Array<BindingStringOrRegex>
  jsxImportSource: string
  reactRefreshHost: string
}

export interface BindingViteReporterPluginConfig {
  root: string
  isTty: boolean
  isLib: boolean
  assetsDir: string
  chunkLimit: number
  warnLargeChunks: boolean
  reportCompressedSize: boolean
  logInfo?: (msg: string) => void
}

export interface BindingViteResolvePluginConfig {
  resolveOptions: BindingViteResolvePluginResolveOptions
  environmentConsumer: string
  environmentName: string
  builtins: Array<BindingStringOrRegex>
  external: true | string[]
  noExternal: true | Array<string | RegExp>
  dedupe: Array<string>
  disableCache?: boolean
  legacyInconsistentCjsInterop?: boolean
  finalizeBareSpecifier?: (resolvedId: string, rawId: string, importer: string | null | undefined) => VoidNullable<string>
  finalizeOtherSpecifiers?: (resolvedId: string, rawId: string) => VoidNullable<string>
  resolveSubpathImports: (id: string, importer: string, isRequire: boolean, scan: boolean) => VoidNullable<string>
  onWarn?: (message: string) => void
  onDebug?: (message: string) => void
  yarnPnp: boolean
}

export interface BindingViteResolvePluginResolveOptions {
  isBuild: boolean
  isProduction: boolean
  asSrc: boolean
  preferRelative: boolean
  isRequire?: boolean
  root: string
  scan: boolean
  mainFields: Array<string>
  conditions: Array<string>
  externalConditions: Array<string>
  extensions: Array<string>
  tryIndex: boolean
  tryPrefix?: string
  preserveSymlinks: boolean
  tsconfigPaths: boolean
}

export interface BindingViteTransformPluginConfig {
  root: string
  include?: Array<BindingStringOrRegex>
  exclude?: Array<BindingStringOrRegex>
  jsxRefreshInclude?: Array<BindingStringOrRegex>
  jsxRefreshExclude?: Array<BindingStringOrRegex>
  isServerConsumer?: boolean
  jsxInject?: string
  transformOptions?: TransformOptions
  yarnPnp?: boolean
}

export interface BindingWatchOption {
  skipWrite?: boolean
  include?: Array<BindingStringOrRegex>
  exclude?: Array<BindingStringOrRegex>
  buildDelay?: number
  usePolling?: boolean
  pollInterval?: number
  compareContentsForPolling?: boolean
  useDebounce?: boolean
  debounceDelay?: number
  debounceTickRate?: number
  onInvalidate?: ((id: string) => void) | undefined
}

export declare function collapseSourcemaps(sourcemapChain: Array<BindingSourcemap>): BindingJsonSourcemap

export declare function enhancedTransform(filename: string, sourceText: string, options: BindingEnhancedTransformOptions | undefined | null, cache: TsconfigCache | undefined | null, yarnPnp: boolean): Promise<BindingEnhancedTransformResult>

export declare function enhancedTransformSync(filename: string, sourceText: string, options: BindingEnhancedTransformOptions | undefined | null, cache: TsconfigCache | undefined | null, yarnPnp: boolean): BindingEnhancedTransformResult

export interface ExtensionAliasItem {
  target: string
  replacements: Array<string>
}

export interface ExternalMemoryStatus {
  freed: boolean
  reason?: string
}

export type FilterTokenKind =  'Id'|
'ImporterId'|
'Code'|
'ModuleType'|
'And'|
'Or'|
'Not'|
'Include'|
'Exclude'|
'CleanUrl'|
'QueryKey'|
'QueryValue';

export declare function initTraceSubscriber(): TraceSubscriberGuard | null

export interface JsChangedOutputs {
  deleted: Set<string>
  changes: Record<string, JsOutputChunk | JsOutputAsset>
}

export interface JsOutputAsset {
  names: Array<string>
  originalFileNames: Array<string>
  filename: string
  source: BindingAssetSource
}

export interface JsOutputChunk {
  name: string
  isEntry: boolean
  isDynamicEntry: boolean
  facadeModuleId?: string
  moduleIds: Array<string>
  exports: Array<string>
  filename: string
  modules: Record<string, BindingRenderedModule>
  imports: Array<string>
  dynamicImports: Array<string>
  code: string
  map?: BindingSourcemap
  sourcemapFilename?: string
  preliminaryFilename: string
}

/** Error emitted from native side, it only contains kind and message, no stack trace. */
export interface NativeError {
  kind: string
  message: string
  /** The id of the file associated with the error */
  id?: string
  /** The exporter associated with the error (for import/export errors) */
  exporter?: string
  /** Location information (line, column, file) */
  loc?: BindingLogLocation
  /** Position in the source file in UTF-16 code units */
  pos?: number
}

export interface PreRenderedChunk {
  /** The name of this chunk, which is used in naming patterns. */
  name: string
  /** Whether this chunk is a static entry point. */
  isEntry: boolean
  /** Whether this chunk is a dynamic entry point. */
  isDynamicEntry: boolean
  /** The id of a module that this chunk corresponds to. */
  facadeModuleId?: string
  /** The list of ids of modules included in this chunk. */
  moduleIds: Array<string>
  /** Exported variable names from this chunk. */
  exports: Array<string>
}

export declare function registerPlugins(id: number, plugins: Array<BindingPluginWithIndex>): void

export declare function resolveTsconfig(filename: string, cache: TsconfigCache | undefined | null, yarnPnp: boolean): BindingTsconfigResult | null

/**
 * Release one holder of the tokio runtime, shutting it down once none are left.
 *
 * This is required for the wasm target with `tokio_unstable` cfg.
 * In the wasm runtime, the `park` threads will hang there until the tokio::Runtime is shutdown.
 */
export declare function shutdownAsyncRuntime(): void

/** Acquire one holder of the tokio runtime, starting it if it is not running. */
export declare function startAsyncRuntime(): void

export interface ViteImportGlobMeta {
  isSubImportsPattern?: boolean
}