GeezerVison

};

}

// Set up internalBinding() in the closure.

/**

* @type {InternalBinding}

* Set up internalBinding() in the closure.

* @type {import('typings/globals').internalBinding}

*/

let internalBinding;

{

"include": ["lib", "doc"],

"exclude": ["src", "tools", "out"],

"files": [

"./typings/internalBinding/async_wrap.d.ts",

"./typings/internalBinding/blob.d.ts",

"./typings/internalBinding/config.d.ts",

"./typings/internalBinding/constants.d.ts",

"./typings/internalBinding/fs.d.ts",

"./typings/internalBinding/http_parser.d.ts",

"./typings/internalBinding/messaging.d.ts",

"./typings/internalBinding/options.d.ts",

"./typings/internalBinding/os.d.ts",

"./typings/internalBinding/serdes.d.ts",

"./typings/internalBinding/symbols.d.ts",

"./typings/internalBinding/timers.d.ts",

"./typings/internalBinding/types.d.ts",

"./typings/internalBinding/url.d.ts",

"./typings/internalBinding/util.d.ts",

"./typings/internalBinding/worker.d.ts",

"./typings/globals.d.ts",

"./typings/primordials.d.ts"

],

"compilerOptions": {

"allowJs": true,

"checkJs": false,

"noEmit": true,

"lib": ["ESNext"],

"lib": ["ESNext", "DOM"],

"target": "ESNext",

"module": "CommonJS",

"baseUrl": ".",

import {AsyncWrapBinding} from "./internalBinding/async_wrap";

import {BlobBinding} from "./internalBinding/blob";

import {ConfigBinding} from "./internalBinding/config";

import {ConstantsBinding} from "./internalBinding/constants";

import {HttpParserBinding} from "./internalBinding/http_parser";

import {FsBinding} from "./internalBinding/fs";

import {MessagingBinding} from "./internalBinding/messaging";

import {OptionsBinding} from "./internalBinding/options";

import {OSBinding} from "./internalBinding/os";

import {SerdesBinding} from "./internalBinding/serdes";

import {SymbolsBinding} from "./internalBinding/symbols";

import {TimersBinding} from "./internalBinding/timers";

import {TypesBinding} from "./internalBinding/types";

import {URLBinding} from "./internalBinding/url";

import {UtilBinding} from "./internalBinding/util";

import {WorkerBinding} from "./internalBinding/worker";

declare type TypedArray =

| Uint8Array

| Uint8ClampedArray

| Float64Array

| BigUint64Array

| BigInt64Array;

interface InternalBindingMap {

async_wrap: AsyncWrapBinding;

blob: BlobBinding;

config: ConfigBinding;

constants: ConstantsBinding;

fs: FsBinding;

http_parser: HttpParserBinding;

messaging: MessagingBinding;

options: OptionsBinding;

os: OSBinding;

serdes: SerdesBinding;

symbols: SymbolsBinding;

timers: TimersBinding;

types: TypesBinding;

url: URLBinding;

util: UtilBinding;

worker: WorkerBinding;

}

type InternalBindingKeys = keyof InternalBindingMap;

declare function internalBinding<T extends InternalBindingKeys>(binding: T): InternalBindingMap[T]

declare global {

namespace NodeJS {

interface Global {

internalBinding<T extends InternalBindingKeys>(binding: T): InternalBindingMap[T]

}

}

}

}

}

declare function InternalBinding(binding: 'async_wrap'): {

export interface AsyncWrapBinding {

setupHooks(): {

init: (

asyncId: number,

kDefaultTriggerAsyncId: 3;

};

Providers: InternalAsyncWrapBinding.Providers;

};

}

}

}

declare function InternalBinding(binding: 'blob'): {

export interface BlobBinding {

createBlob(sources: Array<Uint8Array | InternalBlobBinding.BlobHandle>, length: number): InternalBlobBinding.BlobHandle;

FixedSizeBlobCopyJob: typeof InternalBlobBinding.FixedSizeBlobCopyJob;

getDataObject(id: string): [handle: InternalBlobBinding.BlobHandle | undefined, length: number, type: string] | undefined;

storeDataObject(id: string, handle: InternalBlobBinding.BlobHandle, size: number, type: string): void;

revokeDataObject(id: string): void;

};

}

declare function InternalBinding(binding: 'config'): {

export interface ConfigBinding {

isDebugBuild: boolean;

hasOpenSSL: boolean;

fipsMode: boolean;

noBrowserGlobals: boolean;

bits: number;

hasDtrace: boolean;

};

}

declare function InternalBinding(binding: 'constants'): {

export interface ConstantsBinding {

os: {

UV_UDP_REUSEADDR: 4;

dlopen: {

TRACE_EVENT_PHASE_LEAVE_CONTEXT: 41;

TRACE_EVENT_PHASE_LINK_IDS: 61;

};

};

}

function internalModuleReadJSON(path: string): [] | [string, boolean];

function internalModuleStat(path: string): number;

function lchown(path: string, uid: number, gid: number, req: FSReqCallback): void;

function lchown(path: string, uid: number, gid: number, req: undefined, ctx: FSSyncContext): void;

function lchown(path: string, uid: number, gid: number, usePromises: typeof kUsePromises): Promise<void>;

function symlink(target: StringOrBuffer, path: StringOrBuffer, type: number, req: FSReqCallback): void;

function symlink(target: StringOrBuffer, path: StringOrBuffer, type: number, req: undefined, ctx: FSSyncContext): void;

function symlink(target: StringOrBuffer, path: StringOrBuffer, type: number, usePromises: typeof kUsePromises): Promise<void>;

function unlink(path: string, req: FSReqCallback): void;

function unlink(path: string, req: undefined, ctx: FSSyncContext): void;

function unlink(path: string, usePromises: typeof kUsePromises): Promise<void>;

function writeString(fd: number, value: string, pos: unknown, encoding: unknown, usePromises: typeof kUsePromises): Promise<number>;

}

declare function InternalBinding(binding: 'fs'): {

export interface FsBinding {

FSReqCallback: typeof InternalFSBinding.FSReqCallback;

FileHandle: typeof InternalFSBinding.FileHandle;

writeBuffer: typeof InternalFSBinding.writeBuffer;

writeBuffers: typeof InternalFSBinding.writeBuffers;

writeString: typeof InternalFSBinding.writeString;

};

}

}

}

declare function InternalBinding(binding: 'http_parser'): {

export interface HttpParserBinding {

methods: string[];

HTTPParser: typeof InternalHttpParserBinding.HTTPParser;

};

}

}

declare function InternalBinding(binding: 'messaging'): {

export interface MessagingBinding {

DOMException: typeof import('internal/per_context/domexception').DOMException;

MessageChannel: typeof InternalMessagingBinding.MessageChannel;

MessagePort: typeof InternalMessagingBinding.MessagePort;

moveMessagePortToContext(port: typeof InternalMessagingBinding.MessagePort, context: any): typeof InternalMessagingBinding.MessagePort;

setDeserializerCreateObjectFunction(func: (deserializeInfo: string) => any): void;

broadcastChannel(name: string): typeof InternalMessagingBinding.MessagePort;

};

}