@socketsecurity/lib 5.24.0 → 5.25.1

package/dist/primordials.d.ts

@@ -0,0 +1,337 @@
+/**
+ * @fileoverview Safe references to built-in functions and constructors.
+ *
+ * Captures references to JavaScript built-ins at module load time, before
+ * user code can tamper with prototypes or globals. Consumers that process
+ * adversarial input (PURL parsers, manifest readers, config validators,
+ * anything that ingests untrusted strings or JSON) should import from here
+ * instead of using globals directly, so prototype-pollution attacks on the
+ * caller realm can't silently redirect library internals.
+ *
+ * Convention follows Node.js's internal primordials module:
+ *
+ * - **Static methods** retain their original name: `ObjectKeys`,
+ *   `ArrayIsArray`, `JSONParse`.
+ * - **Prototype methods** are uncurried via `uncurryThis`, so you call
+ *   `StringPrototypeSlice(str, 0, 3)` instead of `str.slice(0, 3)`.
+ * - **Constructors** get a `Ctor` suffix to avoid shadowing the capital-
+ *   case global: `MapCtor`, `SetCtor`.
+ *
+ * **IMPORTANT**: do not use destructuring on `globalThis` or `Reflect`
+ * here. tsgo has a bug that mis-transpiles destructured exports.
+ * See: https://github.com/SocketDev/socket-packageurl-js/issues/3
+ *
+ * @see https://github.com/nicolo-ribaudo/tc39-proposal-primordials
+ * @see https://github.com/nodejs/node/blob/main/lib/internal/per_context/primordials.js
+ */
+export declare const uncurryThis: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, ...args: A) => R;
+export declare const applyBind: <T, A extends readonly unknown[], R>(fn: (this: T, ...args: A) => R) => (self: T, args: A) => R;
+export declare const ArrayCtor: ArrayConstructor;
+export declare const ArrayBufferCtor: ArrayBufferConstructor;
+export declare const BooleanCtor: BooleanConstructor;
+export declare const BufferCtor: typeof globalThis.Buffer | undefined;
+export declare const DataViewCtor: DataViewConstructor;
+export declare const DateCtor: DateConstructor;
+export declare const ErrorCtor: ErrorConstructor;
+export declare const AggregateErrorCtor: AggregateErrorConstructor;
+export declare const EvalErrorCtor: EvalErrorConstructor;
+export declare const RangeErrorCtor: RangeErrorConstructor;
+export declare const ReferenceErrorCtor: ReferenceErrorConstructor;
+export declare const SyntaxErrorCtor: SyntaxErrorConstructor;
+export declare const TypeErrorCtor: TypeErrorConstructor;
+export declare const URIErrorCtor: URIErrorConstructor;
+export declare const MapCtor: MapConstructor;
+export declare const NumberCtor: NumberConstructor;
+export declare const ObjectCtor: ObjectConstructor;
+export declare const PromiseCtor: PromiseConstructor;
+export declare const RegExpCtor: RegExpConstructor;
+export declare const SetCtor: SetConstructor;
+export declare const StringCtor: StringConstructor;
+export declare const SymbolCtor: SymbolConstructor;
+export declare const Float32ArrayCtor: Float32ArrayConstructor;
+export declare const Float64ArrayCtor: Float64ArrayConstructor;
+export declare const Int8ArrayCtor: Int8ArrayConstructor;
+export declare const Int16ArrayCtor: Int16ArrayConstructor;
+export declare const Int32ArrayCtor: Int32ArrayConstructor;
+export declare const Uint8ArrayCtor: Uint8ArrayConstructor;
+export declare const Uint8ClampedArrayCtor: Uint8ClampedArrayConstructor;
+export declare const Uint16ArrayCtor: Uint16ArrayConstructor;
+export declare const Uint32ArrayCtor: Uint32ArrayConstructor;
+export declare const URLCtor: typeof URL;
+export declare const URLSearchParamsCtor: typeof URLSearchParams;
+export declare const WeakMapCtor: WeakMapConstructor;
+export declare const WeakRefCtor: WeakRefConstructor;
+export declare const WeakSetCtor: WeakSetConstructor;
+export declare const decodeComponent: typeof decodeURIComponent;
+export declare const encodeComponent: typeof encodeURIComponent;
+export declare const JSONParse: (text: string, reviver?: (this: any, key: string, value: any) => any) => any;
+export declare const JSONStringify: {
+    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+};
+export declare const ArrayFrom: {
+    <T>(arrayLike: ArrayLike<T>): T[];
+    <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+    <T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+    <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+};
+export declare const ArrayIsArray: (arg: any) => arg is any[];
+export declare const ArrayOf: <T>(...items: T[]) => T[];
+export declare const ArrayBufferIsView: (arg: any) => arg is ArrayBufferView;
+export declare const ArrayPrototypeAt: (self: unknown, index: number) => any;
+export declare const ArrayPrototypeConcat: <T>(self: T[], ...items: Array<T | readonly T[]>) => T[];
+export declare const ArrayPrototypeCopyWithin: (self: unknown, target: number, start: number, end?: number | undefined) => any[];
+export declare const ArrayPrototypeEntries: (self: unknown) => ArrayIterator<[number, any]>;
+export declare const ArrayPrototypeEvery: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => boolean;
+export declare const ArrayPrototypeFill: (self: unknown, value: any, start?: number | undefined, end?: number | undefined) => any[];
+export declare const ArrayPrototypeFilter: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => any[];
+export declare const ArrayPrototypeFind: (self: unknown, predicate: (value: any, index: number, obj: any[]) => unknown, thisArg?: any) => any;
+export declare const ArrayPrototypeFindIndex: (self: unknown, predicate: (value: any, index: number, obj: any[]) => unknown, thisArg?: any) => number;
+export declare const ArrayPrototypeFindLast: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => any;
+export declare const ArrayPrototypeFindLastIndex: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => number;
+export declare const ArrayPrototypeFlat: <A, D extends number = 1>(self: A, depth?: D | undefined) => FlatArray<A, D>[];
+export declare const ArrayPrototypeFlatMap: <U, This = undefined>(self: unknown, callback: (this: This, value: any, index: number, array: any[]) => U | readonly U[], thisArg?: This | undefined) => U[];
+export declare const ArrayPrototypeForEach: (self: unknown, callbackfn: (value: any, index: number, array: any[]) => void, thisArg?: any) => void;
+export declare const ArrayPrototypeIncludes: (self: unknown, searchElement: any, fromIndex?: number | undefined) => boolean;
+export declare const ArrayPrototypeIndexOf: (self: unknown, searchElement: any, fromIndex?: number | undefined) => number;
+export declare const ArrayPrototypeJoin: (self: unknown, separator?: string | undefined) => string;
+export declare const ArrayPrototypeKeys: (self: unknown) => ArrayIterator<number>;
+export declare const ArrayPrototypeLastIndexOf: (self: unknown, searchElement: any, fromIndex?: number | undefined) => number;
+export declare const ArrayPrototypeMap: <U>(self: unknown, callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[];
+export declare const ArrayPrototypePop: (self: unknown) => any;
+export declare const ArrayPrototypePush: <T>(self: T[], ...items: T[]) => number;
+export declare const ArrayPrototypeReduce: (self: unknown, callbackfn: (previousValue: unknown, currentValue: any, currentIndex: number, array: any[]) => unknown, initialValue: unknown) => unknown;
+export declare const ArrayPrototypeReduceRight: (self: unknown, callbackfn: (previousValue: unknown, currentValue: any, currentIndex: number, array: any[]) => unknown, initialValue: unknown) => unknown;
+export declare const ArrayPrototypeReverse: (self: unknown) => any[];
+export declare const ArrayPrototypeShift: (self: unknown) => any;
+export declare const ArrayPrototypeSlice: (self: unknown, start?: number | undefined, end?: number | undefined) => any[];
+export declare const ArrayPrototypeSome: (self: unknown, predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any) => boolean;
+export declare const ArrayPrototypeSort: (self: unknown, compareFn?: ((a: any, b: any) => number) | undefined) => any[];
+export declare const ArrayPrototypeSplice: <T>(self: T[], start: number, deleteCount?: number, ...items: T[]) => T[];
+export declare const ArrayPrototypeToReversed: (self: unknown) => any[];
+export declare const ArrayPrototypeToSorted: (self: unknown, compareFn?: ((a: any, b: any) => number) | undefined) => any[];
+export declare const ArrayPrototypeUnshift: <T>(self: T[], ...items: T[]) => number;
+export declare const ArrayPrototypeValues: (self: unknown) => ArrayIterator<any>;
+export declare const BufferAlloc: typeof Buffer.alloc | undefined;
+export declare const BufferAllocUnsafe: typeof Buffer.allocUnsafe | undefined;
+export declare const BufferAllocUnsafeSlow: typeof Buffer.allocUnsafeSlow | undefined;
+export declare const BufferByteLength: typeof Buffer.byteLength | undefined;
+export declare const BufferConcat: typeof Buffer.concat | undefined;
+export declare const BufferFrom: typeof Buffer.from | undefined;
+export declare const BufferIsBuffer: typeof Buffer.isBuffer | undefined;
+export declare const BufferIsEncoding: typeof Buffer.isEncoding | undefined;
+export declare const BufferPrototypeSlice: ((buf: Buffer, start?: number, end?: number) => Buffer) | undefined;
+export declare const BufferPrototypeToString: ((buf: Buffer, encoding?: BufferEncoding, start?: number, end?: number) => string) | undefined;
+export declare const DateNow: () => number;
+export declare const DateParse: (s: string) => number;
+export declare const DateUTC: {
+    (year: number, monthIndex: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number;
+    (year: number, monthIndex?: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number;
+};
+export declare const DatePrototypeGetTime: (self: unknown) => number;
+export declare const DatePrototypeToISOString: (self: unknown) => string;
+export declare const DatePrototypeValueOf: (self: unknown) => number;
+export declare const ErrorIsError: ((value: unknown) => value is Error) | undefined;
+export declare const FunctionPrototypeApply: (self: (...args: unknown[]) => unknown, thisArg: unknown, args: unknown[]) => unknown;
+export declare const FunctionPrototypeBind: (self: (...args: unknown[]) => unknown, thisArg: unknown, ...args: unknown[]) => (...args: unknown[]) => unknown;
+export declare const FunctionPrototypeCall: (self: (...args: unknown[]) => unknown, thisArg: unknown, ...args: unknown[]) => unknown;
+export declare const IteratorPrototypeNext: (self: Iterator<unknown, any, any>) => IteratorResult<unknown, any>;
+export declare const IteratorPrototypeReturn: ((self: Iterator<unknown, any, any>, value?: unknown) => IteratorResult<unknown, any>) | undefined;
+export declare const MapPrototypeClear: (self: unknown) => void;
+export declare const MapPrototypeDelete: (self: unknown, key: any) => boolean;
+export declare const MapPrototypeEntries: (self: unknown) => MapIterator<[any, any]>;
+export declare const MapPrototypeForEach: (self: unknown, callbackfn: (value: any, key: any, map: Map<any, any>) => void, thisArg?: any) => void;
+export declare const MapPrototypeGet: (self: unknown, key: any) => any;
+export declare const MapPrototypeHas: (self: unknown, key: any) => boolean;
+export declare const MapPrototypeKeys: (self: unknown) => MapIterator<any>;
+export declare const MapPrototypeSet: (self: unknown, key: any, value: any) => Map<any, any>;
+export declare const MapPrototypeValues: (self: unknown) => MapIterator<any>;
+export declare const MathAbs: (x: number) => number;
+export declare const MathCeil: (x: number) => number;
+export declare const MathFloor: (x: number) => number;
+export declare const MathMax: (...values: number[]) => number;
+export declare const MathMin: (...values: number[]) => number;
+export declare const MathPow: (x: number, y: number) => number;
+export declare const MathRandom: () => number;
+export declare const MathRound: (x: number) => number;
+export declare const MathSign: (x: number) => number;
+export declare const MathSqrt: (x: number) => number;
+export declare const MathTrunc: (x: number) => number;
+export declare const NumberIsFinite: (number: unknown) => boolean;
+export declare const NumberIsInteger: (number: unknown) => boolean;
+export declare const NumberIsNaN: (number: unknown) => boolean;
+export declare const NumberIsSafeInteger: (number: unknown) => boolean;
+export declare const NumberParseFloat: (string: string) => number;
+export declare const NumberParseInt: (string: string, radix?: number) => number;
+export declare const NumberPrototypeToFixed: (self: unknown, fractionDigits?: number | undefined) => string;
+export declare const NumberPrototypeToString: (self: unknown, radix?: number | undefined) => string;
+export declare const ObjectAssign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
+    <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+    (target: object, ...sources: any[]): any;
+};
+export declare const ObjectCreate: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+};
+export declare const ObjectDefineProperties: <T>(o: T, properties: PropertyDescriptorMap & ThisType<any>) => T;
+export declare const ObjectDefineProperty: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T;
+export declare const ObjectEntries: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): [string, T][];
+    (o: {}): [string, any][];
+};
+export declare const ObjectFreeze: {
+    <T extends Function>(f: T): T;
+    <T extends {
+        [idx: string]: U | null | undefined | object;
+    }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>;
+    <T>(o: T): Readonly<T>;
+};
+export declare const ObjectFromEntries: {
+    <T = any>(entries: Iterable<readonly [PropertyKey, T]>): {
+        [k: string]: T;
+    };
+    (entries: Iterable<readonly any[]>): any;
+};
+export declare const ObjectGetOwnPropertyDescriptor: (o: any, p: PropertyKey) => PropertyDescriptor | undefined;
+export declare const ObjectGetOwnPropertyDescriptors: <T>(o: T) => { [P in keyof T]: TypedPropertyDescriptor<T[P]>; } & {
+    [x: string]: PropertyDescriptor;
+};
+export declare const ObjectGetOwnPropertyNames: (o: any) => string[];
+export declare const ObjectGetOwnPropertySymbols: (o: any) => symbol[];
+export declare const ObjectGetPrototypeOf: (o: any) => any;
+export declare const ObjectHasOwn: (o: object, v: PropertyKey) => boolean;
+export declare const ObjectIs: (value1: any, value2: any) => boolean;
+export declare const ObjectIsExtensible: (o: any) => boolean;
+export declare const ObjectIsFrozen: (o: any) => boolean;
+export declare const ObjectIsSealed: (o: any) => boolean;
+export declare const ObjectKeys: {
+    (o: object): string[];
+    (o: {}): string[];
+};
+export declare const ObjectPreventExtensions: <T>(o: T) => T;
+export declare const ObjectSeal: <T>(o: T) => T;
+export declare const ObjectSetPrototypeOf: (o: any, proto: object | null) => any;
+export declare const ObjectValues: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): T[];
+    (o: {}): any[];
+};
+export declare const ObjectPrototype: Object;
+export declare const ObjectPrototypeHasOwnProperty: (self: unknown, v: PropertyKey) => boolean;
+export declare const ObjectPrototypeIsPrototypeOf: (self: unknown, v: Object) => boolean;
+export declare const ObjectPrototypePropertyIsEnumerable: (self: unknown, v: PropertyKey) => boolean;
+export declare const ObjectPrototypeToString: (self: unknown) => string;
+export declare const ObjectPrototypeValueOf: (self: unknown) => Object;
+export declare const PromiseAll: {
+    <T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;
+    <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;
+};
+export declare const PromiseAllSettled: {
+    <T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;
+    <T>(values: Iterable<T | PromiseLike<T>>): Promise<PromiseSettledResult<Awaited<T>>[]>;
+};
+export declare const PromiseAny: {
+    <T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
+    <T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
+};
+export declare const PromiseRace: {
+    <T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
+    <T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
+};
+export declare const PromiseReject: <T = never>(reason?: any) => Promise<T>;
+export declare const PromiseResolve: {
+    (): Promise<void>;
+    <T>(value: T): Promise<Awaited<T>>;
+    <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>;
+};
+export declare const PromiseWithResolvers: typeof Promise.withResolvers | undefined;
+export declare const PromisePrototypeCatch: <TResult = never>(self: unknown, onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>;
+export declare const PromisePrototypeFinally: (self: unknown, onfinally?: (() => void) | null | undefined) => Promise<any>;
+export declare const PromisePrototypeThen: <TResult1 = any, TResult2 = never>(self: unknown, onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+export declare const ReflectApply: typeof Reflect.apply;
+export declare const ReflectConstruct: typeof Reflect.construct;
+export declare const ReflectDefineProperty: typeof Reflect.defineProperty;
+export declare const ReflectDeleteProperty: typeof Reflect.deleteProperty;
+export declare const ReflectGet: typeof Reflect.get;
+export declare const ReflectGetOwnPropertyDescriptor: typeof Reflect.getOwnPropertyDescriptor;
+export declare const ReflectGetPrototypeOf: typeof Reflect.getPrototypeOf;
+export declare const ReflectHas: typeof Reflect.has;
+export declare const ReflectIsExtensible: typeof Reflect.isExtensible;
+export declare const ReflectOwnKeys: typeof Reflect.ownKeys;
+export declare const ReflectPreventExtensions: typeof Reflect.preventExtensions;
+export declare const ReflectSet: typeof Reflect.set;
+export declare const ReflectSetPrototypeOf: typeof Reflect.setPrototypeOf;
+export declare const RegExpEscape: ((s: string) => string) | undefined;
+export declare const RegExpPrototypeExec: (self: unknown, string: string) => RegExpExecArray | null;
+export declare const RegExpPrototypeTest: (self: unknown, string: string) => boolean;
+export declare const RegExpPrototypeSymbolMatch: (self: RegExp, str: string) => unknown;
+export declare const RegExpPrototypeSymbolReplace: (self: RegExp, str: string, replaceValue: string) => string;
+export declare const SetPrototypeAdd: (self: unknown, value: any) => Set<any>;
+export declare const SetPrototypeClear: (self: unknown) => void;
+export declare const SetPrototypeDelete: (self: unknown, value: any) => boolean;
+export declare const SetPrototypeEntries: (self: unknown) => SetIterator<[any, any]>;
+export declare const SetPrototypeForEach: (self: unknown, callbackfn: (value: any, value2: any, set: Set<any>) => void, thisArg?: any) => void;
+export declare const SetPrototypeHas: (self: unknown, value: any) => boolean;
+export declare const SetPrototypeKeys: (self: unknown) => SetIterator<any>;
+export declare const SetPrototypeValues: (self: unknown) => SetIterator<any>;
+export declare const StringFromCharCode: (...codes: number[]) => string;
+export declare const StringFromCodePoint: (...codePoints: number[]) => string;
+export declare const StringRaw: (template: {
+    raw: readonly string[] | ArrayLike<string>;
+}, ...substitutions: any[]) => string;
+export declare const StringPrototypeAt: (self: unknown, index: number) => string | undefined;
+export declare const StringPrototypeCharAt: (self: unknown, pos: number) => string;
+export declare const StringPrototypeCharCodeAt: (self: unknown, index: number) => number;
+export declare const StringPrototypeCodePointAt: (self: unknown, pos: number) => number | undefined;
+export declare const StringPrototypeConcat: (self: string, ...strs: string[]) => string;
+export declare const StringPrototypeEndsWith: (self: unknown, searchString: string, endPosition?: number | undefined) => boolean;
+export declare const StringPrototypeIncludes: (self: unknown, searchString: string, position?: number | undefined) => boolean;
+export declare const StringPrototypeIndexOf: (self: unknown, searchString: string, position?: number | undefined) => number;
+export declare const StringPrototypeLastIndexOf: (self: unknown, searchString: string, position?: number | undefined) => number;
+export declare const StringPrototypeLocaleCompare: (self: unknown, that: string, locales?: Intl.LocalesArgument, options?: Intl.CollatorOptions | undefined) => number;
+export declare const StringPrototypeMatch: (self: string, matcher: string | RegExp) => RegExpMatchArray | null;
+export declare const StringPrototypeMatchAll: (self: string, matcher: string | RegExp) => IterableIterator<RegExpMatchArray>;
+export declare const StringPrototypeNormalize: (self: unknown, form?: string | undefined) => string;
+export declare const StringPrototypePadEnd: (self: unknown, maxLength: number, fillString?: string | undefined) => string;
+export declare const StringPrototypePadStart: (self: unknown, maxLength: number, fillString?: string | undefined) => string;
+export declare const StringPrototypeRepeat: (self: unknown, count: number) => string;
+export declare const StringPrototypeReplace: (self: string, searchValue: string | RegExp, replaceValue: string | ((substring: string, ...args: any[]) => string)) => string;
+export declare const StringPrototypeReplaceAll: (self: string, searchValue: string | RegExp, replaceValue: string | ((substring: string, ...args: any[]) => string)) => string;
+export declare const StringPrototypeSearch: (self: unknown, searcher: {
+    [Symbol.search](string: string): number;
+}) => number;
+export declare const StringPrototypeSlice: (self: unknown, start?: number | undefined, end?: number | undefined) => string;
+export declare const StringPrototypeSplit: (self: string, separator: string | RegExp, limit?: number) => string[];
+export declare const StringPrototypeStartsWith: (self: unknown, searchString: string, position?: number | undefined) => boolean;
+export declare const StringPrototypeSubstring: (self: unknown, start: number, end?: number | undefined) => string;
+export declare const StringPrototypeToLocaleLowerCase: (self: unknown, locales?: Intl.LocalesArgument) => string;
+export declare const StringPrototypeToLocaleUpperCase: (self: unknown, locales?: Intl.LocalesArgument) => string;
+export declare const StringPrototypeToLowerCase: (self: unknown) => string;
+export declare const StringPrototypeToUpperCase: (self: unknown) => string;
+export declare const StringPrototypeTrim: (self: unknown) => string;
+export declare const StringPrototypeTrimEnd: (self: unknown) => string;
+export declare const StringPrototypeTrimStart: (self: unknown) => string;
+export declare const SymbolAsyncIterator: symbol;
+export declare const SymbolFor: (key: string) => symbol;
+export declare const SymbolIterator: symbol;
+export declare const SymbolToPrimitive: symbol;
+export declare const SymbolToStringTag: symbol;
+export declare const URLSearchParamsPrototypeAppend: (self: unknown, name: string, value: string) => void;
+export declare const URLSearchParamsPrototypeDelete: (self: unknown, name: string, value?: string | undefined) => void;
+export declare const URLSearchParamsPrototypeForEach: <TThis = import("url").URLSearchParams>(self: unknown, fn: (this: TThis, value: string, name: string, searchParams: import("url").URLSearchParams) => void, thisArg?: TThis | undefined) => void;
+export declare const URLSearchParamsPrototypeGet: (self: unknown, name: string) => string | null;
+export declare const URLSearchParamsPrototypeGetAll: (self: unknown, name: string) => string[];
+export declare const URLSearchParamsPrototypeHas: (self: unknown, name: string, value?: string | undefined) => boolean;
+export declare const URLSearchParamsPrototypeSet: (self: unknown, name: string, value: string) => void;
+export declare const WeakMapPrototypeDelete: (self: unknown, key: WeakKey) => boolean;
+export declare const WeakMapPrototypeGet: (self: unknown, key: WeakKey) => any;
+export declare const WeakMapPrototypeHas: (self: unknown, key: WeakKey) => boolean;
+export declare const WeakMapPrototypeSet: (self: unknown, key: WeakKey, value: any) => WeakMap<WeakKey, any>;
+export declare const WeakSetPrototypeAdd: (self: unknown, value: WeakKey) => WeakSet<WeakKey>;
+export declare const WeakSetPrototypeDelete: (self: unknown, value: WeakKey) => boolean;
+export declare const WeakSetPrototypeHas: (self: unknown, value: WeakKey) => boolean;