index.d.cts

/* auto-generated by NAPI-RS */
/* eslint-disable */

import type { ReadableStream } from 'node:stream/web'

type MaybePromise<T> = T | Promise<T>

export declare const NAPI_RS_SYMBOL: symbol

export declare class ExternalObject<T> {
  readonly '': {
    readonly '': unique symbol
    [K: symbol]: T
  }
}

export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array
/**
 * `constructor` option for `struct` requires all fields to be public,
 * otherwise tag impl fn as constructor
 * #[napi(constructor)]
 */
export declare class Animal {
  /** Kind of animal */
  readonly kind: Kind
  /** This is the constructor */
  constructor(kind: Kind, name: string)
  /** This is a factory method */
  static withKind(kind: Kind): Animal
  get name(): string
  set name(name: string)
  get type(): Kind
  set type(kind: Kind)
  get optionalValue(): number | null
  /**
   * This is to test that setter with optional parameter generates valid TypeScript.
   * TypeScript does not allow optional parameters in setters (TS1051).
   */
  set optionalValue(value: number | undefined | null)
  /**
   * This is a
   * multi-line comment
   * with an emoji 🚀
   */
  whoami(): string
  /** This is static... */
  static getDogKind(): Kind
  /**
   * Here are some characters and character sequences
   * that should be escaped correctly:
   * \[]{}/\:""{
   * }
   * Accept header "*\/json" should not break the comment block
   */
  returnOtherClass(): Dog
  returnOtherClassWithCustomConstructor(): Bird
  overrideIndividualArgOnMethod(normalTy: string, overriddenTy: {n: string}): Bird
}

export declare class AnimalWithDefaultConstructor {
  name: string
  kind: number
  constructor(name: string, kind: number)
}

export declare class AnotherClassForEither {
  constructor()
}

export declare class AnotherCssStyleSheet {
  get rules(): CssRuleList
}
export type AnotherCSSStyleSheet = AnotherCssStyleSheet

export declare class Asset {
  constructor()
  get filePath(): number
}
export type JsAsset = Asset

export declare class Assets {
  constructor()
  get(id: number): JsAsset | null
}
export type JsAssets = Assets

/**
 * This type implements JavaScript's async iterable protocol.
 * It can be used with `for await...of` loops.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_async_iterator_and_async_iterable_protocols
 */
export declare class AsyncDataSource {
  [Symbol.asyncIterator](): AsyncGenerator<string, void, undefined>
  /** Creates an async data source that yields each item with a simulated I/O delay */
  static fromData(data: Array<string>, delayMs: number): AsyncDataSource
}

/**
 * This type implements JavaScript's async iterable protocol.
 * It can be used with `for await...of` loops.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_async_iterator_and_async_iterable_protocols
 */
export declare class AsyncFib {
  [Symbol.asyncIterator](): AsyncGenerator<number, void, number | undefined>
  constructor()
}

export declare class AsyncThrowClass {

  constructor()
  asyncThrowError(): Promise<void>
}

export declare class Bird {
  name: string
  constructor(name: string)
  getCount(): number
  getNameAsync(): Promise<string>
  acceptSliceMethod(slice: Uint8Array): number
}

/** Smoking test for type generation */
export declare class Blake2BHasher {
  static withKey(key: Blake2bKey): Blake2BHasher
  update(data: Buffer): void
}
export type Blake2bHasher = Blake2BHasher

export declare class Blake2BKey {

}
export type Blake2bKey = Blake2BKey

export declare class CatchOnConstructor {
  constructor()
}

export declare class CatchOnConstructor2 {
  constructor()
}

export declare class ClassInArray {
  constructor(value: number)
}

export declare class ClassReturnInPromise {

}

export declare class ClassWithFactory {
  name: string
  static withName(name: string): ClassWithFactory
  static with4Name(name: string): Promise<ClassWithFactory>
  static with4NameResult(name: string): Promise<ClassWithFactory>
  setName(name: string): this
}

export declare class ClassWithLifetime {
  constructor()
  getName(): string
}

export declare class Context {
  maybeNeed?: boolean
  buffer: Uint8Array
  constructor()
  static withData(data: string): Context
  static withBuffer(buf: Uint8Array): Context
  method(): string
}

/**
 * This type implements JavaScript's async iterable protocol.
 * It can be used with `for await...of` loops.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_async_iterator_and_async_iterable_protocols
 */
export declare class CounterRepro {
  constructor(max: number)
  [Symbol.asyncIterator](): AsyncGenerator<number, void, undefined>
}

export declare class CreateStringClass {
  static new(): CreateStringClass
  createString(): string | null
  createStringResult(): string
}

export declare class CssRuleList {
  getRules(): Array<string>
  get parentStyleSheet(): CSSStyleSheet
  get name(): string | null
}
export type CSSRuleList = CssRuleList

export declare class CssStyleSheet {
  constructor(name: string, rules: Array<string>)
  get rules(): CssRuleList
  anotherCssStyleSheet(): AnotherCssStyleSheet
}
export type CSSStyleSheet = CssStyleSheet

export declare class CustomFinalize {
  constructor(width: number, height: number)
}

export declare class CustomStruct {
  static customStatusCodeForFactory(): CustomStruct
  constructor()
}

export declare class DefaultUseNullableClass {
  requiredNumberField: number
  requiredStringField: string
  optionalNumberField?: number
  optionalStringField?: string
  constructor(requiredNumberField: number, requiredStringField: string, optionalNumberField?: number, optionalStringField?: string)
}

/**
 * This type implements JavaScript's async iterable protocol.
 * It can be used with `for await...of` loops.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_async_iterator_and_async_iterable_protocols
 */
export declare class DelayedCounter {
  [Symbol.asyncIterator](): AsyncGenerator<number, string, undefined>
  /** Creates a counter that yields values from 0 to max-1 with a delay between each */
  constructor(max: number, delayMs: number)
}

export declare class Dog {
  name: string
  constructor(name: string)
}

/**
 * This type extends JavaScript's `Iterator`, and so has the iterator helper
 * methods. It may extend the upcoming TypeScript `Iterator` class in the future.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator#iterator_helper_methods
 * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-6.html#iterator-helper-methods
 */
export declare class Fib extends Iterator<number, void, number> {
  constructor()
  next(value?: number): IteratorResult<number, void>
}

/**
 * This type extends JavaScript's `Iterator`, and so has the iterator helper
 * methods. It may extend the upcoming TypeScript `Iterator` class in the future.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator#iterator_helper_methods
 * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-6.html#iterator-helper-methods
 */
export declare class Fib2 extends Iterator<number, void, number> {
  static create(seed: number): Fib2
  next(value?: number): IteratorResult<number, void>
}

/**
 * This type extends JavaScript's `Iterator`, and so has the iterator helper
 * methods. It may extend the upcoming TypeScript `Iterator` class in the future.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator#iterator_helper_methods
 * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-6.html#iterator-helper-methods
 */
export declare class Fib3 extends Iterator<number, void, number> {
  current: number
  nextNum: number
  constructor(current: number, nextNum: number)
  next(value?: number): IteratorResult<number, void>
}

/**
 * This type extends JavaScript's `Iterator`, and so has the iterator helper
 * methods. It may extend the upcoming TypeScript `Iterator` class in the future.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator#iterator_helper_methods
 * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-6.html#iterator-helper-methods
 */
export declare class Fib4 extends Iterator<unknown, void, number> {
  current: number
  nextItem: number
  constructor(current: number, nextItem: number)
  toJSON(): Array<number>
  next(value?: number): IteratorResult<unknown, void>
}

export declare class GetterSetterWithClosures {
  constructor()
}

export declare class JsClassForEither {
  constructor()
}

export declare class JSOnlyMethodsClass {
  data: string
  processData(): string
  getLength(): number
}
export type RustOnlyMethodsClass = JSOnlyMethodsClass

export declare class JsRemote {
  constructor(repo: JsRepo)
  name(): string
}

export declare class JsRepo {
  constructor(dir: string)
  remote(): JsRemote
}

export declare class MyJsNamedClass {
  constructor(value: string)
  getValue(): string
  multiplyValue(times: number): string
}
export type OriginalRustNameForJsNamedStruct = MyJsNamedClass

export declare class NinjaTurtle {
  name: string
  static isInstanceOf(value: unknown): boolean
  /** Create your ninja turtle! 🐢 */
  static newRaph(): NinjaTurtle
  getMaskColor(): string
  getName(): string
  returnThis(): this
}

export declare class NotUseNullableClass {
  requiredNumberField: number
  requiredStringField: string
  optionalNumberField?: number
  optionalStringField?: string
  constructor(requiredNumberField: number, requiredStringField: string, optionalNumberField?: number, optionalStringField?: string)
}

export declare class NotWritableClass {
  name: string
  constructor(name: string)
  setName(name: string): void
}

export declare class Optional {
  static optionEnd(required: string, optional?: string | undefined | null): string
  static optionStart(optional: string | undefined | null, required: string): string
  static optionStartEnd(optional1: string | undefined | null, required: string, optional2?: string | undefined | null): string
  static optionOnly(optional?: string | undefined | null): string
}

export declare class PackageJsonReader {
  constructor()
  read(): any
}

export declare class Reader {

  constructor()
  read(): Buffer
}

/**
 * Regression fixture for issue #3378. `Vec` conversion reads JavaScript array
 * elements, so an indexed getter can synchronously reenter before conversion
 * has finished.
 */
export declare class ReentrantBorrowOrderTest {
  values: Array<number>
  constructor()
  replaceValues(values: Array<number>): void
  replaceValuesFromThis(this: object): void
}

export declare class Selector {
  orderBy: Array<string>
  select: Array<string>
  struct: string
  where?: string
  constructor(orderBy: Array<string>, select: Array<string>, struct: string, where?: string)
}

export declare class Thing {

}

export declare class ThingList {
  constructor()
  get thing(): Thing
}

export declare class UseNullableClass {
  requiredNumberField: number
  requiredStringField: string
  nullableNumberField: number | null
  nullableStringField: string | null
  constructor(requiredNumberField: number, requiredStringField: string, nullableNumberField: number | null, nullableStringField: string | null)
}

export declare class Width {
  value: number
  constructor(value: number)
}

export interface A {
  foo: number
}

export declare function acceptArraybuffer(fixture: ArrayBuffer): bigint

export declare function acceptSlice(fixture: Uint8Array): bigint

export declare function acceptStream(stream: ReadableStream<Uint8Array>): Promise<Buffer>

export declare function acceptThreadsafeFunction(func: ((err: Error | null, arg: number) => any)): void

export declare function acceptThreadsafeFunctionFatal(func: ((arg: number) => void)): void

export declare function acceptThreadsafeFunctionTupleArgs(func: ((err: Error | null, arg0: number, arg1: boolean, arg2: string) => any)): void

export declare function acceptThreadsafeFunctionTupleNoFnArgs(func: ((err: Error | null, arg: [number, boolean, string]) => any)): void

export declare function acceptUint8ClampedSlice(input: Uint8ClampedArray): bigint

export declare function acceptUint8ClampedSliceAndBufferSlice(a: Buffer, b: Uint8ClampedArray): bigint

export declare function acceptUntypedTypedArray(input: TypedArray): bigint

export declare function add(a: number, b: number): number

export declare const enum ALIAS {
  A = 0,
  B = 1
}

export interface AliasedStruct {
  a: ALIAS
  b: number
}

export interface AllOptionalObject {
  name?: string
  age?: number
}

export declare function appendBuffer(buf: Buffer): Buffer

export declare function appendToOsString(s: string): string

export declare function apply0(ctx: Animal, callback: () => void): void

export declare function apply1(ctx: Animal, callback: (arg: string) => void, name: string): void

export declare function arrayBufferFromData(): ArrayBuffer

export declare function arrayBufferFromExternal(): ArrayBuffer

export declare function arrayBufferLenAsync(buf: Uint8Array): Promise<number>

export declare function arrayBufferPassThrough(buf: Uint8Array): Promise<Uint8Array>

export declare function arrayParams(arr: Array<number>): number

export declare function asyncBufferToArray(buf: ArrayBuffer): Array<number>

export declare function asyncMultiTwo(arg: number): Promise<number>

export declare function asyncPlus100(p: Promise<number>): Promise<number>

export declare function asyncReduceBuffer(buf: Buffer): Promise<number>

export declare function asyncResolveArray(inner: number): Promise<unknown[]>

export declare function asyncTaskArraybuffer(data: Array<number>): Promise<ArrayBuffer>

export declare function asyncTaskFinally(inner: object): Promise<void>

export declare function asyncTaskOptionalReturn(): Promise<number | null>

export declare function asyncTaskReadFile(path: string): Promise<Buffer>

export declare function asyncTaskVoidReturn(): Promise<void>

/**
 * Awaits `promise` on the async runtime; a rejection materializes as an
 * `Error` carrying a `napi_ref` and is dropped here, off the JS thread.
 * Returns `true` when the promise rejected.
 */
export declare function awaitRejectionOffThread(promise: Promise<undefined>): Promise<boolean>

export interface B {
  bar: number
}

export declare function bigintAdd(a: bigint, b: bigint): bigint

export declare function bigintFromI128(): bigint

export declare function bigintFromI64(): bigint

export declare function bigintGetU64AsString(bi: bigint): string

export interface BindingVitePluginMeta {
  'vite:import-glob': ViteImportGlobMeta
}

export declare function btreeSetToJs(): Set<string>

export declare function btreeSetToRust(set: Set<string>): void

export declare function bufferLenAsync(buf: Buffer): Promise<number>

export declare function bufferPassThrough(buf: Buffer): Promise<Buffer>

export declare function bufferWithAsyncBlock(buf: Buffer): Promise<number>

export declare function buildThreadsafeFunctionFromFunction(callback: (arg0: number, arg1: number) => number): void

export declare function buildThreadsafeFunctionFromFunctionCalleeHandle(callback: () => void): void

export interface C {
  baz: number
}

export declare function call0(callback: () => number): number

export declare function call1(callback: (arg: number) => number, arg: number): number

export declare function call2(callback: (arg0: number, arg1: number) => number, arg1: number, arg2: number): number

export declare function callAsyncWithUnknownReturnValue(tsfn: ((err: Error | null, arg: number) => unknown)): Promise<number>

export declare function callbackInSpawn(callback: (arg: object) => unknown): void

export declare function callbackReturnPromise<T>(functionInput: () => T | Promise<T>, callback: (err: Error | null, result: T) => void): T | Promise<T>

export declare function callbackReturnPromiseAndSpawn(jsFunc: (arg0: string) => Promise<string>): Promise<string>

export declare function callCatchOnPromise(input: Promise<number>): Promise<string>

export declare function callFinallyOnPromise(input: Promise<number>, onFinally: () => void): Promise<number>

export declare function callFunction(cb: () => number): number

export declare function callFunctionWithArg(cb: (arg0: number, arg1: number) => number, arg0: number, arg1: number): number

export declare function callFunctionWithArgAndCtx(ctx: Animal, cb: (arg: string) => void, name: string): void

export declare function callLongThreadsafeFunction(tsfn: ((err: Error | null, arg: number) => unknown)): void

export declare function callRuleHandler(rule: Rule, arg: number): number

export declare function callThenOnPromise(input: Promise<number>): Promise<string>

export declare function callThreadsafeFunction(tsfn: ((err: Error | null, arg: number) => unknown)): void

export declare function callWithNestedFunctionArg(callback: (arg: (arg: number) => number) => number): number

export declare function callWithTupleArg(callback: (arg: [number, number]) => number, arg1: number, arg2: number): number

export declare function captureErrorInCallback(cb1: () => void, cb2: (arg0: Error) => void): void

export declare function chronoDateAdd1Minute(input: Date): Date

export declare function chronoDateFixtureReturn1(): Date

export declare function chronoDateFixtureReturn2(): Date

export declare function chronoDateWithTimezoneReturn(): Date | null

export declare function chronoDateWithTimezoneToMillis(input: Date): number

export declare function chronoLocalDateReturn(): Date | null

export declare function chronoLocalDateToMillis(input: Date): number

export declare function chronoNativeDateTime(date: Date): number

export declare function chronoNativeDateTimeReturn(): Date | null

export declare function chronoUtcDateReturn(): Date | null

export declare function chronoUtcDateToMillis(input: Date): number

/**
 * Creates and deletes `count` references on the calling JS thread, so
 * concurrent off-thread releases have live `GlobalHandles` traffic to race
 * with (this is what made the corruption deterministic in napi-rs#3368).
 */
export declare function churnGlobalHandles(value: unknown, count: number): void

export declare function cleanupReentrantBorrowOrderTestTargets(): number

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 declare function compressSync(_: string | Uint8Array): Buffer

export declare function concatLatin1(s: string): string

export declare function concatStr(s: string): string

export declare function concatUtf16(s: string): string

export declare function contains(source: string, target: string): boolean

export declare function convertU32Array(input: Uint32Array): Array<number>

export declare function createArraybuffer(): ArrayBuffer

export declare function createBigInt(): bigint

export declare function createBigIntI64(): bigint

export declare function createBufferSliceFromCopiedData(): Buffer

/**
 * Regression guard for the off-thread `FunctionRef` drop.
 *
 * A `create_with_stream_bytes` output whose pull future REJECTS (the underlying
 * stream yields an `Err` item, or the output is cancelled while a pull is parked)
 * drops the pull resolver — which owns the controller's `enqueue`/`close`
 * `FunctionRef`s — on a Tokio worker thread rather than the JS thread. A
 * `FunctionRef` holds a thread-affine `napi_ref`; deleting it off the JS thread
 * mutates V8's `GlobalHandles` concurrently with the JS thread and corrupts the
 * heap, surfacing later as a SIGSEGV/SIGBUS inside V8/napi. This emits one `Ok`
 * chunk then a terminal `Err`, so JS can loop it and assert the process stays
 * alive (see the matching test in `__tests__/values.spec.ts`).
 */
export declare function createErroringReadableStream(): ReadableStream<Buffer>

export declare function createExternal(size: number): ExternalObject<number>

export declare function createExternalBufferSlice(): Buffer

export declare function createExternalLatin1CustomFinalize(): string

export declare function createExternalLatin1Empty(): string

export declare function createExternalLatin1Long(): string

export declare function createExternalLatin1Short(): string

export declare function createExternalLatin1String(): string

export declare function createExternalLatin1WithLatin1Chars(): string

export declare function createExternalRef(size: number): ExternalObject<number>

export declare function createExternalString(content: string): ExternalObject<string>

export declare function createExternalTypedArray(): Uint32Array

export declare function createExternalUtf16String(): string

export declare function createFunction(): (arg: number) => number

export declare function createI32ArrayFromExternal(): Int32Array

export declare function createNotUseNullableStruct(): NotUseNullableStruct

export declare function createObj(): object

export declare function createObjectRef(): object

export declare function createObjectWithClassField(): ObjectFieldClassInstance

export declare function createObjWithProperty(): { value: ArrayBuffer, get getter(): number }

export declare function createOptionalExternal(size?: number | undefined | null): ExternalObject<number> | null

export declare function createReadableStream(): ReadableStream<Buffer>

export declare function createReadableStreamFromClass(readableStreamClass: typeof ReadableStream): ReadableStream<Buffer>

/**
 * Creates a ReadableStream that emits StreamItem objects.
 * This demonstrates streaming custom Rust structs to JavaScript.
 */
export declare function createReadableStreamWithObject(): ReadableStream<StreamItem>

/**
 * Create a class-branded object whose wrap can be removed without touching
 * the generated class instance's reference/finalizer bookkeeping.
 */
export declare function createReentrantBorrowOrderTestTarget(constructor: new (...args: any[]) => unknown): object

export declare function createReferenceOnFunction(cb: () => void): Promise<void>

export declare function createRejectedPromise(message: string): Promise<number>

export declare function createResolvedPromise(value: number): Promise<number>

export declare function createStaticLatin1String(): string

export declare function createStaticUtf16String(): string

export declare function createSymbol(): symbol

export declare function createSymbolFor(desc: string): symbol

export declare function createSymbolRef(desc: string): symbol

export declare function createUint8ClampedArrayFromData(): Uint8ClampedArray

export declare function createUint8ClampedArrayFromExternal(): Uint8ClampedArray

export declare function createUseNullableStruct(): UseNullableStruct

export declare function createZeroCopyLatin1String(): string

export declare function createZeroCopyUtf16String(): string

/** You could break the step and for an new continuous value. */
export declare const enum CustomNumEnum {
  One = 1,
  Two = 2,
  Three = 3,
  Four = 4,
  Six = 6,
  Eight = 8,
  Nine = 9,
  Ten = 10
}

export declare function customStatusCode(): void

export declare const enum CustomStringEnum {
  Foo = 'my-custom-value',
  Bar = 'Bar',
  Baz = 'Baz'
}

export type CustomU32 =
  number

export interface Data {
  data: string | Buffer
}

export interface DatesWithTimeZone {
  start: Date
  end?: Date
}

export declare function dateToNumber(input: Date): number

/** This is a const */
export const DEFAULT_COST: number

export interface DefaultUseNullableStruct {
  requiredNumberField: number
  requiredStringField: string
  optionalNumberField?: number
  optionalStringField?: string
}

export declare function defineClass(): typeof DynamicRustClass

class DynamicRustClass {
  constructor(value: number)
  rustMethod(): number
}

export declare function derefUint8Array(a: Uint8Array, b: Uint8ClampedArray): number

/**
 * Detach the native value without constructing a second Rust receiver during
 * reentry. Cleanup is deliberately deferred until the outer native call has
 * returned or thrown, because the old code generation keeps using the cached
 * pointer after input conversion.
 */
export declare function detachReentrantBorrowOrderTestTarget(target: unknown): void

/**
 * Counts the chunks read from a stream, swallowing (dropping) any read error.
 *
 * Regression guard: the read error is dropped here inside the async block, which runs
 * on the Tokio runtime thread rather than the JS thread. A `Reader` rejection that
 * carried a raw JS `napi_ref` would release that reference off the JS thread on drop,
 * aborting the process; the owned-error conversion makes this safe.
 */
export declare function drainStreamCount(stream: ReadableStream<Uint8Array>): Promise<number>

/**
 * `try_clone` shares one `napi_ref` between siblings via an `Arc<ErrorRef>`;
 * dropping a sibling is an atomic refcount decrement, and the underlying
 * reference is released only when the LAST sibling drops. Here the original
 * drops on the JS thread first (a plain decrement, no release), then the last
 * sibling drops off-thread — so the release is routed through the custom-GC
 * TSFN, exactly the path a shared reference must survive without corrupting
 * V8's GlobalHandles from a foreign thread.
 */
export declare function dropClonedErrorsOnTwoThreads(value: unknown): void

/**
 * Converts `value` into an `Error` — creating a `napi_ref` to it, the same
 * code path a `Promise` rejection takes — and drops it on a spawned thread.
 */
export declare function dropErrorFromValueOffThread(value: unknown): void

export declare function either3(input: string | number | boolean): number

export declare function either4(input: string | number | boolean | Obj): number

export declare function eitherBoolOrFunction(input: boolean | ((arg?: unknown) => unknown)): void

export declare function eitherBoolOrTuple(input: boolean | [boolean, string]): void

export declare function eitherF64OrU32(input: number): number

export declare function eitherFromObjects(input: A | B | C): string

export declare function eitherFromOption(): JsClassForEither | undefined

export declare function eitherPromiseInEitherA(input: Promise<number> | number | string): Promise<boolean>

export declare function eitherStringOrNumber(input: string | number): number

export declare const enum Empty {

}

export declare function enumToI32(e: CustomNumEnum): number

export declare function errorMessageContainsNullByte(msg: string): void

export declare function esmResolve(next: () => Promise<undefined>): Promise<undefined>

export declare function extendsJavascriptError(errorClass: any): void

export type ExternalLinterLoadPluginCb =
  ((arg: string) => PluginLoadResult)

export type ExternalLinterLoadPluginCb2 =
  ((arg: string) => PluginLoadResult)

export declare function f32ArrayToArray(input: Float32Array): Array<number>

export declare function f64ArrayToArray(input: Float64Array): Array<number>

export declare function fetch(url: string, requestInit?: RequestInit | undefined | null): Promise<import('undici-types').Response>

export declare function fibonacci(n: number): number

export declare function fnReceivedAliased(s: AliasedStruct, e: ALIAS): void

export interface FunctionData {
  handle: () => number
}

export declare function generateFunctionAndCallIt(): FunctionData

export declare function getBigintJsonValue(value: bigint): void

export declare function getBtreeMapping(): Record<string, number>

export declare function getBuffer(): Buffer

export declare function getBufferSlice(): Buffer

export declare function getClassFromArray(arr: unknown[]): number | null

export declare function getCwd(callback: (arg0: string) => void): void

export declare function getEmptyBuffer(): Buffer

export declare function getEmptyTypedArray(): Uint8Array

export declare function getExternal(external: ExternalObject<number>): number

export declare function getGlobal(): typeof global

export declare function getIndexMapping(): Record<string, number>

export declare function getIndexMappingWithHasher(): Record<string, number>

export declare function getMapping(): Record<string, number>

export declare function getMappingWithHasher(): Record<string, number>

export declare function getModuleFileName(): string

export declare function getMyVec(): MyVec

export declare function getNestedNumArr(): number[][][]

export declare function getNull(): null

export declare function getNullByteProperty(obj: object): string | null

export declare function getNumArr(): number[]

/** Gets some numbers */
export declare function getNums(): Array<number>

export declare function getOptionalExternal(external?: ExternalObject<number> | undefined | null): number | null

export declare function getPackageJsonName(packageJson: PackageJson): string

export declare function getStrFromObject(): void

export declare function getterFromObj(): number

export declare function getTuple(val: [number, string, number]): number

export declare function getUndefined(): void

export declare function getWords(): Array<string>

export declare function i16ArrayToArray(input: Int16Array): Array<number>

export declare function i32ArrayToArray(input: Int32Array): Array<number>

export declare function i64ArrayToArray(input: BigInt64Array): Array<number>

export declare function i8ArrayToArray(input: Int8Array): Array<number>

export declare function indexmapPassthrough(fixture: Record<string, number>): Record<string, number>

export declare function indexSetToJs(): Set<string>

export declare function indexSetToRust(set: Set<string>): void

export declare function intoUtf8(s: string): string

export declare function joinPath(path: string, segment: string): string

export declare function jsErrorCallback(value: unknown): Array<Error>

/** default enum values are continuos i32s start from 0 */
export declare const enum Kind {
  /** Barks */
  Dog = 0,
  /** Kills birds */
  Cat = 1,
  /** Tasty */
  Duck = 2
}

/** default enum values are continuos i32s start from 0 */
export declare const enum KindInValidate {
  /** Barks */
  Dog = 0,
  /** Kills birds */
  Cat = 1,
  /** Tasty */
  Duck = 2
}

export interface Latin1MethodsResult {
  length: number
  isEmpty: boolean
  asSlice: Array<number>
}

export type LifetimeOnlyHandler =
  (arg: string) => string

export declare function listObjKeys(obj: object): Array<string>

export interface LocalDates {
  start: Date
  end?: Date
}

export declare function mapOption(val?: number | undefined | null): number | null

export declare function mergeTupleArray(t1: TupleToArray, t2: TupleToArray): TupleToArray

export interface Meta {
  merge: boolean
}

export declare function mutateArraybuffer(buf: ArrayBuffer): void

export declare function mutateExternal(external: ExternalObject<number>, newVal: number): void

export declare function mutateOptionalExternal(external: ExternalObject<number> | undefined | null, newVal: number): void

export declare function mutateTypedArray(input: Float32Array): void

export type MyPromise =
  string | Promise<string>

export type MyVec =
  Array<number | string>

/** Nested metadata for demonstrating object streaming with complex types */
export interface NestedMetadata {
  hello: string
}

export interface NotUseNullableStruct {
  requiredNumberField: number
  requiredStringField: string
  optionalNumberField?: number
  optionalStringField?: string
}

export type Nullable<T> =
  T | undefined | null

export interface Obj {
  v: string | number
}

export interface ObjectFieldClassInstance {
  bird: Bird
}

export declare function objectGetNamedPropertyShouldPerformTypecheck(obj: { foo: number; bar: string; }): void

export interface ObjectOnlyFromJs {
  count: number
  callback: ((err: Error | null, arg: number) => any)
}

export interface ObjectOnlyToJs {
  name: number
  dependencies: any
}

export declare function objectWithCApis(): object

export declare function optionalCallbackTypes(callback?: ((arg: string) => unknown) | undefined | null): void

export declare function optionEnd(callback: (arg0: string, arg1?: string | undefined | null) => void): void

export declare function optionOnly(callback: (arg0?: string | undefined | null) => void): void

export declare function optionStart(callback: (arg0: string | undefined | null, arg1: string) => void): void

export declare function optionStartEnd(callback: (arg0: string | undefined | null, arg1: string, arg2?: string | undefined | null) => void): void

export declare function overrideIndividualArgOnFunction(notOverridden: string, f: () => string, notOverridden2: number): string

export declare function overrideIndividualArgOnFunctionWithCbArg(callback: (town: string, name?: string | undefined | null) => string, notOverridden: number): object

export declare function overrideWholeFunctionType(operation: 'add' | 'subtract' | 'multiply', a: number, b: number): number

/** This is an interface for package.json */
export interface PackageJson {
  name: string
  /** The version of the package */
  version: string
  dependencies?: Record<string, any>
  devDependencies?: Record<string, any>
}

export declare function panic(): void

export declare function panicInAsync(): Promise<void>

export declare function passSetToJs(): Set<string>

export declare function passSetToRust(set: Set<string>): void

export declare function passSetWithHasherToJs(): Set<string>

export declare function pathParent(path: string): string | null

export interface Pet {
  name: string
  kind: number
  eitherTsfn: string | ((err: Error | null, arg: number) => number)
}

export interface PluginLoadResult {
  name: string
  version: string
}

export declare function plusOne(this: Width): number

export declare function promiseInEither(input: number | Promise<number>): Promise<boolean>

export declare function promiseRawReturnClassInstance(): Promise<ClassReturnInPromise>

export interface PropertyNameDigitTest {
  /** Property names starting with digits should be quoted */
  '0invalid': string
  '123': string
}

export interface PropertyNameSpecialCharsTest {
  /** Special characters should be quoted */
  'kebab-case': string
  'with space': string
  'dot.notation': string
  'xml:lang': string
  /** Dollar sign should be quoted for backward compatibility */
  '$var': string
}

export interface PropertyNameUnicodeTest {
  /** Unicode characters should NOT be quoted */
  café: string
  日本語: string
  Ελληνικά: string
}

export interface PropertyNameValidTest {
  /** Valid identifiers should NOT be quoted */
  camelCase: string
  pascalCase: string
  private: string
  with123Numbers: string
}

/** napi = { version = 2, features = ["serde-json"] } */
export declare function readFile(callback: (arg0: Error | undefined, arg1?: string | undefined | null) => void): void

export declare function readFileAsync(path: string): Promise<Buffer>

export declare function readPackageJson(): PackageJson

export declare function receiveAllOptionalObject(obj?: AllOptionalObject | undefined | null): void

export declare function receiveBindingVitePluginMeta(meta: BindingVitePluginMeta): void

export declare function receiveBufferSliceWithLifetime(data: Data): number

export declare function receiveClassOrNumber(either: number | JsClassForEither): number

export declare function receiveDifferentClass(either: JsClassForEither | AnotherClassForEither): number

export declare function receiveMutClassOrNumber(either: number | JsClassForEither): number

export declare function receiveObjectOnlyFromJs(obj: { count: number, callback: (err: Error | null, count: number) => void }): void

export declare function receiveObjectWithClassField(object: ObjectFieldClassInstance): Bird

export declare function receiveStrictObject(strictObject: StrictObject): void

export declare function receiveString(s: string): string

export declare function referenceAsCallback(callback: (arg0: number, arg1: number) => number, arg0: number, arg1: number): number

export declare function referenceWithTupleArg(callback: (arg: [number, number]) => number, arg0: number, arg1: number): number

export interface RequestInit {
  method?: string
  headers?: Record<string, string>
}

export declare function returnCString(): string

export declare function returnEither(input: number): string | number

export declare function returnEitherClass(input: number): number | JsClassForEither

export declare function returnFromSharedCrate(): Shared

export declare function returnNull(): null

export declare function returnObjectOnlyToJs(): ObjectOnlyToJs

export declare function returnUndefined(): void

export declare function returnUndefinedIfInvalid(input: boolean): boolean

export declare function returnUndefinedIfInvalidPromise(input: Promise<boolean>): Promise<boolean>

export declare function roundtripStr(s: string): string

export interface Rule {
  name: string
  handler: RuleHandler<number, number>
}

export type RuleHandler<Args, Ret> =
  (arg: Args) => Ret

export declare function runScript(script: string): unknown

export declare function setNullByteProperty(obj: object): void

export declare function setSymbolInObj(symbol: symbol): object

export declare function shorterEscapableScope(createString: () => string | null): string

export declare function shorterScope(arr: unknown[]): Array<number>

export declare function shutdownRuntime(): void

export declare function spawnFutureLifetime(input: number): Promise<string>

export declare function spawnThreadInThread(tsfn: ((err: Error | null, arg: number) => number)): void

export declare function stashBufferInThreadLocal(buf: Buffer): void

/**
 * Stashes a JS-derived `Error` in a Rust thread_local on the calling JS
 * thread. In a worker it drops at thread-exit, AFTER env teardown — the
 * release must no-op (leak), not use-after-free.
 */
export declare function stashErrorInThreadLocal(value: unknown): void

export declare function stashTypedArrayInThreadLocal(buf: Uint8Array): void

export declare const enum Status {
  Pristine = 'Pristine',
  Loading = 'Loading',
  Ready = 'Ready'
}

export declare const enum StatusInValidate {
  Poll = 'Poll',
  Ready = 'Ready',
  Done = 'Done'
}

/** Example struct demonstrating object streaming with nested types */
export interface StreamItem {
  something: NestedMetadata
  name: string
  size: number
}

export interface StrictObject {
  name: string
}

export declare const enum StringEnum {
  VariantOne = 'variantone',
  VariantTwo = 'varianttwo',
  VariantThree = 'variantthree'
}

export type StructuredKind =
  | { type2: 'Hello' }
  | { type2: 'Greeting', name: string }
  | { type2: 'Optional', name?: string }
  | { type2: 'Birthday', name: string, age: number }
  | { type2: 'Tuple', field0: number, field1: number }

export type StructuredKindLowercase =
  | { type: 'hello' }
  | { type: 'greeting', name: string }
  | { type: 'optional', name?: string }
  | { type: 'birthday', name: string, age: number }
  | { type: 'tuple', field0: number, field1: number }

export declare function sumBtreeMapping(nums: Record<string, number>): number

export declare function sumIndexMapping(nums: Record<string, number>): number

export declare function sumMapping(nums: Record<string, number>): number

export declare function sumNums(nums: Array<number>): number

/**
 * Function to test escaped quotes in comments.
 * This comment contains escaped quotes: \\"g+sx\\" and should not break JSON parsing.
 * The pattern \\"value\\" is commonly used in regex and shell commands.
 * Another example: sed 's/old/\\"new\\"/g' where quotes are escaped.
 */
export declare function testEscapedQuotesInComments(input: string): string

export declare function testLatin1Methods(input: string): Latin1MethodsResult

export declare function testSerdeBigNumberPrecision(number: string): any

export declare function testSerdeBufferBytes(obj: object): bigint

export declare function testSerdeRoundtrip(data: any): any

export declare function testWorkers(amount: number, completeCallback: ((err: Error | null, ) => void)): void

export declare function threadsafeFunctionBuildThrowErrorWithStatus(cb: (arg?: unknown) => unknown): void

export declare function threadsafeFunctionClosureCapture(defaultValue: Animal, func: (arg: Animal) => void): void

export declare function threadsafeFunctionFatalMode(cb: ((arg: boolean) => unknown)): void

export declare function threadsafeFunctionFatalModeError(cb: ((arg: boolean) => string)): void

export declare function threadsafeFunctionThrowError(cb: ((err: Error | null, arg: boolean) => unknown)): void

export declare function threadsafeFunctionThrowErrorWithStatus(cb: ((err: Error | null, arg: boolean) => unknown)): void

export declare function throwAsyncError(): Promise<void>

/**
 * A reference-less `Error` tagged `Status::PendingException` (the shape a
 * JS-thrown error takes after `try_clone` off the owning thread drops its
 * `napi_ref`) must still be thrown to JS, not silently swallowed. `throw_into`
 * used to skip throwing on that status alone; it now only skips when the env
 * genuinely has a pending exception. Returned as `Err` from a sync `#[napi]`
 * function so it flows through `throw_into`.
 */
export declare function throwDetachedPendingException(): void

export declare function throwError(): void

export declare function throwErrorWithCause(): void

export declare function throwSyntaxError(error: string, code?: string | undefined | null): void

export declare function toJsObj(): object

/**
 * Regression cover for napi-rs#3370 cause preservation: a JS `Error` carrying
 * a `.cause` cloned off the owning thread must keep the cause chain (rebuilt
 * reference-lessly), not drop it — otherwise the surfaced error loses its
 * underlying cause. Extracts the JS `.cause` into the Rust `Error`'s `cause`
 * field on the JS thread, clones off-thread, and returns the cloned error's
 * cause message (empty string if the cause was lost).
 */
export declare function tryCloneErrorCauseOffThread(value: unknown): string

/**
 * Regression cover for the *transitive* clone case: clone the JS-derived
 * `Error` once ON the owning JS thread (a reference-sharing clone), then move
 * that clone to another thread and clone it AGAIN. Because the on-thread clone
 * keeps a reference-less cause backup, the off-thread re-clone must still carry
 * the cause chain — cause survival must not depend on the order of clones.
 * Returns the re-clone's cause message (empty string if the cause was lost).
 */
export declare function tryCloneErrorCauseTransitiveOffThread(value: unknown): string

/**
 * Regression cover for napi-rs#3370: `try_clone` off the owning JS thread
 * can't share the thread-affine `napi_ref`, so it must return a reference-less
 * copy that still carries the message — NOT a guard placeholder that discards
 * it. rolldown relies on this to surface plugin errors from its build workers
 * (it does `try_clone().unwrap_or_else(|e| e)` off-thread). Returns the cloned
 * error's message so the test can assert it survived the off-thread clone.
 */
export declare function tryCloneErrorOffThread(value: unknown): string

/**
 * Regression cover for off-thread *fidelity*: an `Error` derived from a JS
 * exception, cloned off the owning thread and then surfaced to JS *on the
 * owning thread*, must reuse the ORIGINAL JS error object — so its `.stack`,
 * subclass, and arbitrary own properties survive, not just the message. This
 * is rolldown's plugin-error path (clone on a build worker, thrown on the JS
 * thread); a reference-less clone would rebuild a bare `Error(message)` and
 * silently drop the stack and props. The clone is made on a spawned thread and
 * returned as `Err`, so it converts back to JS on the owning thread — where
 * `into_value` reads the shared reference and returns the very same object.
 */
export declare function tryCloneErrorOffThreadKeepReference(value: unknown): void

export declare function tsfnAsyncCall(func: (arg0: number, arg1: number, arg2: number) => string): Promise<void>

export declare function tsfnCallWithCallback(tsfn: ((err: Error | null, ) => string)): void

export declare function tsfnInEither(pet: Pet): void

export declare function tsfnReturnPromise(func: ((err: Error | null, arg: number) => Promise<number>)): Promise<number>

export declare function tsfnReturnPromiseTimeout(func: ((err: Error | null, arg: number) => Promise<number>)): Promise<number>

export declare function tsfnThrowFromJs(tsfn: ((err: Error | null, arg: number) => Promise<number>)): Promise<number>

export declare function tsfnThrowFromJsCallbackContainsTsfn(tsfn: ((err: Error | null, arg: number) => Promise<number>)): Promise<void>

export declare function tsfnThrowFromJsCatch(tsfn: ((arg0: string) => void)): Promise<void>

export declare function tsfnThrowFromJsCatchDropInThread(tsfn: ((arg0: string) => void)): Promise<string>

export declare function tsfnThrowFromJsCatchHandled(tsfn: ((err: Error | null, arg0: string) => void)): Promise<void>

export declare function tsfnThrowFromJsCatchRecover(tsfn: ((arg0: string) => void)): Promise<void>

export declare function tsfnWeak(tsfn: (() => void)): Promise<void>

export declare function tsRename(a: { foo: number }): string[]

export interface TsTypeChanged {
  typeOverride: object
  typeOverrideOptional?: object
}

export interface TupleObject {
  customField: number
  field1: number
}

export type TupleToArray =
  [field0: string, field1: number, field2?: Meta]

export declare function u16ArrayToArray(input: Uint16Array): Array<number>

export declare function u32ArrayToArray(input: Uint32Array): Array<number>

export declare function u64ArrayToArray(input: BigUint64Array): Array<bigint>

export declare function u8ArrayToArray(input: Uint8Array): Array<number>

export declare function uInit8ArrayFromString(): Promise<Uint8Array>

export declare function uint8ArrayFromData(): Uint8Array

export declare function uint8ArrayFromExternal(): Uint8Array

export interface UseNullableStruct {
  requiredNumberField: number
  requiredStringField: string
  nullableNumberField: number | null
  nullableStringField: string | null
}

export interface UtcDates {
  start: Date
  end?: Date
}

export declare function validateArray(arr: Array<number>): number

export declare function validateBigint(input: bigint): bigint

export declare function validateBoolean(i: boolean): boolean

export declare function validateBuffer(b: Buffer): number

export declare function validateBufferSlice(input: Buffer): number

export declare function validateDate(d: Date): number

export declare function validateDateTime(d: Date): number

export declare function validateEnum(input: KindInValidate): number

export declare function validateExternal(e: ExternalObject<number>): number

export declare function validateFunction(cb: () => number): number

export declare function validateHashMap(input: Record<string, number>): number

export declare function validateNull(i: null): boolean

export declare function validateNumber(i: number): number

export declare function validateOptional(input1?: string | undefined | null, input2?: boolean | undefined | null): boolean

export declare function validatePromise(p: Promise<number>): Promise<number>

export declare function validateString(s: string): string

export declare function validateStringEnum(input: StatusInValidate): string

export declare function validateStructuredEnum(kind: StructuredKind): StructuredKind

export declare function validateStructuredEnumLowercase(kind: StructuredKindLowercase): StructuredKindLowercase

export declare function validateSymbol(s: symbol): boolean

export declare function validateTypedArray(input: Uint8Array): number

export declare function validateTypedArraySlice(input: Uint8Array): number

export declare function validateUint8ClampedSlice(input: Uint8ClampedArray): number

export declare function validateUndefined(i: undefined): boolean

export interface ViteImportGlobMeta {
  isSubImportsPattern?: boolean
}

export type VoidNullable<T = void> =
  Nullable<T>

export declare function withAbortController(a: number, b: number, signal: AbortSignal): Promise<number>

export declare function withAbortSignalHandle(signal: AbortSignal): Promise<number>

export declare function withinAsyncRuntimeIfAvailable(): void

export declare function withoutAbortController(a: number, b: number): Promise<number>

export declare function xxh64Alias(input: Buffer): bigint

export declare namespace xxh2 {
  export function xxh2Plus(a: number, b: number): number
  export function xxh3Xxh64Alias(input: Buffer): bigint
}

export declare namespace xxh3 {
  /** Xxh3 class */
  export class Xxh3 {
    constructor()
    /** update */
    update(input: Buffer): void
    digest(): bigint
  }
  export const ALIGNMENT: number
  /** xxh128 function */
  export function xxh128(input: Buffer): bigint
  export function xxh3_64(input: Buffer): bigint
}
export declare class ComplexClass {
  value: string
  number: number
  constructor(value: string | ComplexClass, number: number)
  methodOne(): string
  methodTwo(): number
  methodThree(): string
  methodFour(): boolean
  methodFive(): string
}

export interface Shared {
  value: number
}