@rpack-dev/core 0.1.6 → 0.1.7-dev-8c5eef6

package/dist/rpack-core.d.ts

@@ -0,0 +1,1244 @@
+// Generated by dts-bundle-generator v9.5.1
+
+/**
+ * The main entrypoint for rPack.dev
+ */
+declare class RPack {
+	private static instance;
+	private static platform;
+	private static readonly platformLoadPromise;
+	static initPlatform(platform: RPPlatform): void;
+	/**
+	 * Creates an instance of the RPack class.
+	 * Use this when instantiating RPack as a library.
+	 * @return a Promise that will resolve with the RPack instance.
+	 */
+	static createInstance(defaultInstance?: boolean): Promise<RPack>;
+	static getInstance(): RPack;
+	private readonly pluginThread;
+	private readonly loadPromise;
+	private readonly platform;
+	private readonly version;
+	private readonly proxyManager;
+	private readonly registryManager;
+	private readonly pluginManager;
+	private readonly networkManager;
+	private constructor();
+	/**
+	 * Returns a promise that completes when this RPack instance has fully loaded.
+	 * Note that this Promise resolves before any plugins are loaded.
+	 * @return a Promise
+	 */
+	getLoadPromise(): Promise<void>;
+	/**
+	 * Returns the platform instance used to create this RPack instance.
+	 * @return the platform instance
+	 */
+	getPlatform(): RPPlatform;
+	/**
+	 * Returns a class that contains version information about rPack and its platform implementation.
+	 * @return an RPVersion instance
+	 */
+	getVersion(): RPVersion;
+	getProxyManager(): ProxyManager;
+	getRegistryManager(): RegistryManager;
+	getPluginManager(): PluginManager;
+	getNetworkManager(): NetworkManager;
+	isPluginThread(): boolean;
+	/**
+	 * Shorthand for getNetworkManager().getPlugin().
+	 *
+	 * @param key the plugin key
+	 * @return a Promise that will resolve with the plugin instance, or `undefined` if the plugin cannot be found
+	 */
+	getPlugin<T extends RPPlugin>(key: string): Promise<RegistryDataFiltered<T> | undefined>;
+}
+export declare abstract class PluginArchive {
+	private readonly map;
+	private manifest;
+	protected constructor();
+	protected abstract resolveEntry(path: string): Promise<Blob | null>;
+	getEntry(path: string): Promise<Blob | null>;
+	abstract getEntries(): Promise<string[]>;
+	getPluginManifest(): Promise<PluginManifest>;
+}
+export declare abstract class RPPlatform {
+	private readonly id;
+	protected constructor(id: string);
+	abstract createRPackInstance(constructor: (options: RPackConstructorOptions) => RPack): Promise<RPack>;
+	abstract createRPackThread(threadId: string, pluginId: string): Promise<RPackThread>;
+}
+export declare abstract class RPackThread {
+	private readonly threadId;
+	private readonly messenger;
+	protected constructor(threadId: string, messenger: Messenger<W2HPackets, H2WPackets>);
+	getThreadId(): string;
+	getMessenger(): Messenger<W2HPackets, H2WPackets>;
+	abstract disable(): Promise<void>;
+	abstract terminate(): Promise<void>;
+}
+export declare class AsyncIterableIteratorMirror<T, E> implements AsyncIterableIterator<T> {
+	private readonly it;
+	private readonly converter;
+	constructor(it: Iterator<T>);
+	constructor(it: Iterator<E>, converter: (e: E) => T);
+	[Symbol.asyncIterator](): AsyncIterableIterator<T>;
+	next(...args: [
+	] | [
+		any
+	]): Promise<IteratorResult<T>>;
+	return(value?: any): Promise<IteratorResult<T>>;
+	throw(e?: any): Promise<IteratorResult<T>>;
+}
+export declare class DevPluginServerClient {
+	private readonly parent;
+	private readonly port;
+	private readonly manifest;
+	private socket?;
+	constructor(parent: DevPluginSource, port: number, manifest: DevPluginSourceServerManifest);
+	init(): void;
+	getAllPlugins(): AsyncIterableIterator<PluginManifest>;
+	getPlugin(groupId: string, pluginId: string): Promise<PluginManifest | null>;
+	getPluginArchive(groupId: string, pluginId: string): Promise<ArrayBuffer>;
+	remove(): void;
+}
+export declare class DevPluginSource implements PluginSource {
+	private static readonly RATE_MULTIPLIER;
+	static DEFAULT_PORT_RANGES: [
+		number,
+		number
+	][];
+	private readonly rpack;
+	private portRanges;
+	private autoScanRate;
+	private autoScanPromise;
+	private autoScanTimeout;
+	private lastFoundPorts;
+	private servers;
+	constructor(rpack: RPack, portRanges: [
+		number,
+		number
+	][], autoScanRate: number);
+	performScan(): Promise<null | undefined>;
+	private scanPorts;
+	getRPack(): RPack;
+	getSourceId(): string;
+	remove(): void;
+	setAutoScanRate(rate: number): void;
+	reloadPlugin(groupId: string, pluginId: string): Promise<void>;
+	getAllPlugins(): AsyncIterableIterator<PluginManifest>;
+	getPlugin(groupId: string, pluginId: string, version?: string): Promise<PluginManifest | null>;
+	getPluginArchive(groupId: string, pluginId: string, version: string): Promise<PluginArchive>;
+}
+export declare class FilteredIterableIterator<T> implements IterableIterator<T> {
+	private readonly it;
+	private readonly filter;
+	constructor(it: Iterator<T>, filter: (t: T) => boolean);
+	constructor(it: Iterator<T>, filter: (t: T) => boolean, undefinedAllowed: false);
+	constructor(it: Iterator<T>, filter: (t: T | undefined) => boolean, undefinedAllowed: true);
+	[Symbol.iterator](): IterableIterator<T>;
+	next(...args: [
+	] | [
+		any
+	]): IteratorResult<T>;
+	return(value?: any): IteratorResult<T>;
+	throw(e?: any): IteratorResult<T>;
+}
+export declare class LazyBatchedAsyncIterableIterator<T> implements AsyncIterableIterator<T> {
+	private readonly supplier;
+	private readonly completeHandler?;
+	private readonly errorHandler?;
+	private lastBatch;
+	private lastIndex;
+	private result?;
+	constructor(supplier: () => Promise<BatchResult<T>>, completeHandler?: (value?: T) => Promise<void>, errorHandler?: (value?: T) => Promise<void>);
+	[Symbol.asyncIterator](): AsyncIterableIterator<T>;
+	next(): Promise<IteratorResult<T, T | undefined>>;
+	return(value?: T): Promise<IteratorResult<T, T | undefined>>;
+	throw(e?: any): Promise<IteratorResult<T, T | undefined>>;
+}
+export declare class LazyPromise<T> {
+	private readonly promise;
+	private completed;
+	private errored;
+	private resolveFunc;
+	private rejectFunc;
+	constructor(promise?: Promise<T>);
+	resolve(result: T): void;
+	reject(error: any): void;
+	getPromise(): Promise<T>;
+	then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+	isComplete(): boolean;
+	isErrored(): boolean;
+}
+export declare class LocalObject<T extends object> implements ProxyHandler<T> {
+	get(target: T, p: string | symbol, receiver: any): any;
+}
+export declare class LocalRegistry<Data, Key extends JSONLike = string> implements Registry<Data, Key> {
+	private readonly manager;
+	private readonly options;
+	private readonly publicOptions;
+	private readonly registryId;
+	private readonly map;
+	constructor(manager: RegistryManager, registryId: string, options: RegistryOptions);
+	getRegistryManager(): RegistryManager;
+	getRegistryId(): string;
+	getOptions(): PublicRegistryOptions;
+	getAllEntriesByThread(ownerThread: string): AsyncIterableIterator<RegistryEntry<Data, Key>>;
+	getAllEntries(): AsyncIterableIterator<RegistryEntry<Data, Key>>;
+	getAll(): AsyncIterableIterator<RegistryDataFiltered<Data>>;
+	get(key: Key): Promise<RegistryDataFiltered<Data> | undefined>;
+	getEntry(key: Key): Promise<RegistryEntry<Data, Key> | undefined>;
+	has(key: Key): Promise<boolean>;
+	add(key: Key, data: Data): Promise<boolean>;
+	remove(key: Key): Promise<boolean>;
+	size(): Promise<number>;
+	/**
+	 * Internal method, do not use.
+	 *
+	 * Remove all values contained by this registry from the target thread.
+	 * @param ownerThread the target thread ID
+	 */
+	__removeAll(ownerThread: string): void;
+	/**
+	 * Internal method, do not use.
+	 *
+	 * Try to add a local value to the registry.
+	 * @param key the key to use
+	 * @param ownerThread the owner thread, or null if sharing is allowed (requires allowShared in the options)
+	 * @param data the data to store
+	 *
+	 * @return true if adding was successful, false otherwise
+	 */
+	__localAdd(key: Key, ownerThread: string | null, data: Data): boolean;
+	__localRemove(key: Key, ownerThread: string): boolean;
+	__localGet(key: Key): RegistryDataFiltered<Data> | undefined;
+}
+export declare class LocalRemoteMap<Local, Remote> {
+	private parent;
+	private localMap;
+	private remoteSet;
+	private registry;
+	constructor(parent: RemoteProxyManager, messenger: Messenger<ProxyPackets, ProxyPackets>, type: ProxyCleanupTarget, cleanup?: (value: Local) => void);
+	private generateKey;
+	addLocal(local: Local, key?: string): string;
+	get(key: string): Local | undefined;
+	delete(key: string): Local | undefined;
+	registerRemote(key: string, remote: Remote): void;
+	has(key: string): boolean;
+	hasRemote(key: string): boolean;
+	deleteRemote(key: string): boolean;
+}
+export declare class Messenger<InPackets extends PacketsType<InPackets>, OutPackets extends PacketsType<OutPackets>> {
+	private readonly handlerLists;
+	private readonly sender;
+	constructor(sender: SenderFunction<OutPackets>);
+	private getHandlerList;
+	/**
+	 * Adds a handler function that will get
+	 * executed whenever a party
+	 * @param key the packet key
+	 * @param handler the packet handler
+	 */
+	addHandler<K extends keyof InPackets>(key: K, handler: PacketHandler<InPackets[K]>): void;
+	removeHandler<K extends keyof InPackets>(key: K, handler: PacketHandler<InPackets[K]>): boolean;
+	private promiseHandlerImpl;
+	addPromiseNonceHandler<K extends keyof OnlyNoncePackets<InPackets>>(key: K, nonce: string, timeout?: number): Promise<InPackets[K]>;
+	addPromiseHandler<K extends keyof InPackets>(key: K, timeout?: number): Promise<InPackets[K]>;
+	receivePacket<K extends keyof InPackets>(packet: InPackets[K]): void;
+	sendPacket<K extends keyof OutPackets>(packet: OutPackets[K]): void;
+	sendPacketWithNoncePromise<O extends keyof OnlyNoncePackets<OutPackets>, I extends keyof OnlyNoncePackets<InPackets>>(outPacketKey: O, outPacket: Omit<OutPackets[O], "nonce" | "id">, inPacket: I, timeout?: number): Promise<InPackets[I]>;
+	static cast<SIn extends TIn, SOut extends TOut, TIn extends PacketsType<TIn>, TOut extends PacketsType<TOut>>(source: Messenger<SIn, SOut>): Messenger<TIn, TOut>;
+}
+export declare class NetworkManager {
+	static readonly HOST_THREAD_ID = "host";
+	private readonly rpack;
+	private hostMessenger?;
+	private threads?;
+	private readonly pluginRegistry;
+	private plugin;
+	private threadId;
+	private readonly wellKnownMap;
+	private readonly wellKnownReverseMap;
+	constructor(rpack: RPack, threadId: string, hostMessenger?: Messenger<H2WPackets, W2HPackets>);
+	private mapWellKnown;
+	__initPlugin(scriptUrl: string): Promise<void>;
+	getRPack(): RPack;
+	getHostMessenger(): Messenger<H2WPackets, W2HPackets> | undefined;
+	getCurrentThreadId(): string;
+	getPlugin<T extends RPPlugin>(key: string): Promise<RegistryDataFiltered<T> | undefined>;
+	getPluginRegistry(): Registry<RPPlugin, string>;
+	__initRemotes(threadId: string, messenger: Messenger<H2WPackets | W2HPackets, H2WPackets | W2HPackets>): void;
+	__createThread(scriptUrl: string): Promise<string>;
+	private ensureJSONInner;
+	private ensureJSON;
+	private getFunctionNames;
+	serialize<T extends Serializable>(threadId: string, target: T, options?: {
+		objectMode?: "registry" | "default";
+	}): MappedSerializedData<T>;
+	deserialize<T extends RegistrySerializedData>(threadId: string, serialized: T): MappedDeserializedData<T>;
+}
+export declare class PluginManager {
+	private readonly rpack;
+	private readonly sources?;
+	constructor(rpack: RPack);
+	getRPack(): RPack;
+}
+export declare class ProxyManager {
+	private readonly rpack;
+	private readonly remotes;
+	constructor(rpack: RPack);
+	createRemote(threadId: string, messenger: Messenger<ProxyPackets, ProxyPackets>): RemoteProxyManager;
+	getRPack(): RPack;
+	getRemote(threadId: string): RemoteProxyManager | undefined;
+}
+/**
+ * Represents the main entrypoint of a plugin.
+ */
+export declare class RPPlugin {
+	/**
+	 * The owning RPack instance.
+	 */
+	private rpack;
+	/**
+	 * Retrieves the RPack instance associated with this plugin..
+	 *
+	 * @return the RPack instance
+	 */
+	getRPack(): RPack;
+	onInit(): Promise<void>;
+	onShutdown(): Promise<void>;
+	/**
+	 * Internal method, do not use.
+	 *
+	 * Sets the underlying RPack property on a
+	 * given RPPlugin instance. This can only
+	 * be done once.
+	 * @param plugin the plugin to modify
+	 * @param rpack the RPack instance
+	 */
+	static __setInstance(plugin: RPPlugin, rpack: RPack): void;
+}
+export declare class RPVersion {
+	private readonly rpackChannel;
+	private readonly rpackVersion;
+	private readonly rpackRepository;
+	private readonly implementationName;
+	private readonly implementationChannel;
+	private readonly implementationVersion;
+	private readonly implementationRepository;
+	constructor(implementationName: string, implementationChannel: string, implementationVersion: string, implementationRepository: string);
+	getRPackChannel(): string;
+	getRPackVersion(): string;
+	getRPackRepository(): string;
+	getImplementationName(): string;
+	getImplementationChannel(): string;
+	getImplementationVersion(): string;
+	getImplementationRepository(): string;
+}
+export declare class RegistryManager {
+	private static readonly META_REGISTRY_ID;
+	static readonly PLUGIN_REGISTRY_ID = "rpack:plugin";
+	private readonly rpack;
+	private readonly remotes;
+	private readonly metaRegistry;
+	constructor(rpack: RPack);
+	createRegistry<Data extends RegistryObject<Data>, Key extends JSONLike = string>(registryId: string, options?: Partial<RegistryOptions>): Promise<Registry<Data, Key>>;
+	createRegistry<Data, Key extends JSONLike = string>(registryId: string, options?: Partial<RegistryOptions> & {
+		localsAreProxied: true;
+	}): Promise<Registry<Data, Key>>;
+	getRPack(): RPack;
+	createRemote(threadId: string, messenger: Messenger<RegistryPackets, RegistryPackets>): RemoteRegistryManager;
+	getRemote(remoteThread: string): RemoteRegistryManager | undefined;
+	getRegistry(registryId: string): Promise<Registry<any, any> | undefined>;
+	__createInternalRegistry<Data, Key extends JSONLike = string>(registryId: string, options: Partial<RegistryOptions>): Registry<Data, Key>;
+	__deserializeRegistry<Data, Key extends JSONLike>(registryId: string, ownerThread: string, options: Required<PublicRegistryOptions>): Registry<Data, Key>;
+}
+/**
+ * A remote asynchronous iterator that operates over
+ * a remotely managed iterator.
+ *
+ * @template T The type of the elements in the remote iterator.
+ */
+export declare class RemoteAsyncIterator<T> implements AsyncIterableIterator<T> {
+	private readonly manager;
+	private readonly iteratorKeySupplier;
+	private iteratorKeyPromise;
+	private iteratorKey;
+	private finished;
+	constructor(manager: RemoteProxyManager, iteratorKeySupplier: () => Promise<string>);
+	[Symbol.asyncIterator](): AsyncIterableIterator<T>;
+	getIteratorKey(): Promise<string>;
+	next(...[value]: [
+	] | [
+		any
+	]): Promise<IteratorResult<T>>;
+	return(value?: any): Promise<IteratorResult<T>>;
+	throw(e?: any): Promise<IteratorResult<T>>;
+}
+export declare class RemoteObject<T extends object> implements ProxyHandler<T> {
+	private readonly remoteProxy;
+	private readonly objectKey;
+	private readonly typeName;
+	private readonly knownProps;
+	private readonly functions;
+	private readonly iterable;
+	private constructor();
+	get(_target: T, prop: string | symbol, _receiver: any): any;
+	ownKeys(_target: T): ArrayLike<string | symbol>;
+	getOwnPropertyDescriptor(target: T, p: string | symbol): PropertyDescriptor | undefined;
+	has(_target: T, prop: string | symbol): boolean;
+	static fromObject(remoteProxy: RemoteProxyManager, serialized: SerializedObject): RemoteObject<object>;
+	static fromRegistryEntry(remoteProxy: RemoteProxyManager, serialized: SerializedRegistryEntry): RemoteObject<object>;
+	static isProxy(object: any): boolean;
+	static getFunctions(object: any): any;
+}
+export declare class RemoteProxyManager {
+	private readonly parent;
+	private readonly threadId;
+	private readonly messenger;
+	private readonly objects;
+	private readonly functions;
+	private readonly iterators;
+	constructor(parent: ProxyManager, threadId: string, messenger: Messenger<ProxyPackets, ProxyPackets>);
+	getThreadId(): string;
+	serialize<T extends Serializable>(target: T, options?: {
+		objectMode?: "registry" | "default";
+	}): MappedSerializedData<T>;
+	deserialize<T extends RegistrySerializedData>(serialized: T): MappedDeserializedData<T>;
+	/**
+	 * Shorthand for sending a response packet that has a value with the messenger.
+	 * Automatically serializes the value passed.
+	 * @param id the packet id
+	 * @param nonce the packet nonce (single use token)
+	 * @param value the value to serialize
+	 * @param data any extra data that is needed
+	 */
+	private sendValue;
+	/**
+	 * Shorthand for sending a response packet that has an error with the messenger.
+	 * Automatically serializes the error passed.
+	 * @param id the packet id
+	 * @param nonce the packet nonce (single use token)
+	 * @param error the error to serialize
+	 */
+	private sendError;
+	/**
+	 * Shorthand for sending a response packet with an error string with the messenger.
+	 * Automatically converts the error string to an error.
+	 * @param id the packet id
+	 * @param nonce the packet nonce (single use token)
+	 * @param errorMsg the value to serialize
+	 */
+	private sendErrorRaw;
+	onObjectRefresh(packet: ProxyRefreshObjectRequestPacket): void;
+	onMethod(packet: ProxyMethodRequestPacket): void;
+	onFunction(packet: ProxyFunctionRequestPacket): void;
+	onIteratorCreate(packet: ProxyCreateIteratorRequestPacket): void;
+	onIteratorNext(packet: ProxyIteratorNextRequestPacket): void;
+	onIteratorClose(packet: ProxyIteratorCloseRequestPacket): void;
+	declareLocalObject(value: any, key?: string): string;
+	declareLocalIterator(it: Iterator<any>): string;
+	declareLocalAsyncIterator(it: AsyncIterator<any>): string;
+	declareFunction(target: SerializableFunction): string;
+	declareRemoteIterator(iteratorKey: string, iterator: RemoteAsyncIterator<any>): void;
+	requestRemoteObjectIterator<T>(objectKey: string): RemoteAsyncIterator<T>;
+	requestRemoteIteratorNext<T>(iteratorKey: string, value?: Serializable): Promise<IteratorResult<T>>;
+	requestRemoteIteratorClose(iteratorKey: string): void;
+	refreshRemote<T>(objectKey: string): Promise<T>;
+	requestRemoteMethod(objectKey: string, method: string, args: any[]): Promise<any>;
+	requestRemoteFunction(functionKey: string, args: Serializable[]): Promise<any>;
+}
+export declare class RemoteRegistry<Data, Key extends JSONLike = string> implements Registry<Data, Key> {
+	private readonly manager;
+	private readonly options;
+	private remoteThread;
+	private registryId;
+	private localEntries;
+	constructor(manager: RegistryManager, remoteThread: string, registryId: string, options: PublicRegistryOptions);
+	private getRemote;
+	getRegistryManager(): RegistryManager;
+	getRegistryId(): string;
+	getOptions(): PublicRegistryOptions;
+	get(key: Key): Promise<RegistryDataFiltered<Data> | undefined>;
+	getEntry(key: Key): Promise<RegistryEntry<Data, Key> | undefined>;
+	getAllEntriesByThread(ownerThread: string): AsyncIterableIterator<RegistryEntry<Data, Key>>;
+	getAllEntries(): AsyncIterableIterator<RegistryEntry<Data, Key>>;
+	getAll(): AsyncIterableIterator<RegistryDataFiltered<Data>>;
+	has(key: Key): Promise<boolean>;
+	add(key: Key, data: Data): Promise<boolean>;
+	remove(key: Key): Promise<boolean>;
+	size(): Promise<number>;
+	__forwardAdd(key: Key, ownerThread: string, data: RegistryDataFiltered<Data>): Promise<boolean>;
+	__forwardRemove(key: Key, ownerThread: string): Promise<boolean>;
+	__localAdd(key: Key, ownerThread: string | null, data: Data): boolean;
+	__localGet(key: Key): RegistryDataFiltered<Data> | undefined;
+}
+export declare class RemoteRegistryManager {
+	private readonly parent;
+	private readonly remoteThreadId;
+	private readonly messenger;
+	constructor(parent: RegistryManager, threadId: string, messenger: Messenger<RegistryPackets, RegistryPackets>);
+	getCurrentThread(): string;
+	private getRemote;
+	private serialize;
+	private deserialize;
+	/**
+	 * Shorthand for sending a response packet that has an error with the messenger.
+	 * Automatically serializes the error passed.
+	 * @param id the packet id
+	 * @param nonce the packet nonce (single use token)
+	 * @param error the error to serialize
+	 */
+	private sendError;
+	/**
+	 * Shorthand for sending a response packet with an error string with the messenger.
+	 * Automatically converts the error string to an error.
+	 * @param id the packet id
+	 * @param nonce the packet nonce (single use token)
+	 * @param errorMsg the value to serialize
+	 */
+	private sendErrorRaw;
+	onAdd(packet: RegistryAddRequestPacket): Promise<void>;
+	onHas(packet: RegistryHasRequestPacket): Promise<void>;
+	onRemove(packet: RegistryRemoveRequestPacket): Promise<void>;
+	onSize(packet: RegistrySizeRequestPacket): Promise<void>;
+	onGet(packet: RegistryGetRequestPacket): Promise<void>;
+	onGetEntry(packet: RegistryGetEntryRequestPacket): Promise<void>;
+	onGetAllEntries(packet: RegistryGetAllEntriesRequestPacket): Promise<void>;
+	onGetAllEntriesByThread(packet: RegistryGetAllEntriesByThreadRequestPacket): Promise<void>;
+	onGetAll(packet: RegistryGetAllRequestPacket): Promise<void>;
+	requestAdd(registryId: string, originThread: string | null, key: JSONLike, value: any): Promise<boolean>;
+	requestHas(registryId: string, key: JSONLike): Promise<boolean>;
+	requestRemove(registryId: string, originThread: string | null, key: JSONLike): Promise<boolean>;
+	requestSize(registryId: string): Promise<number>;
+	requestGet<Data>(registryId: string, key: JSONLike): Promise<RegistryDataFiltered<Data> | undefined>;
+	requestGetEntry<Data, Key extends JSONLike>(registryId: string, key: JSONLike): Promise<RegistryEntry<Data, Key> | undefined>;
+	requestGetAllEntries<Data, Key extends JSONLike>(registryId: string): RemoteAsyncIterator<RegistryEntry<Data, Key>>;
+	requestGetAllEntriesByThread<Data, Key extends JSONLike>(registryId: string, ownerThread: string): RemoteAsyncIterator<RegistryEntry<Data, Key>>;
+	requestGetAll<Data>(registryId: string): RemoteAsyncIterator<Data>;
+}
+/**
+ * A collection of string-related utilities.
+ */
+export declare class StringUtils {
+	/** A string containing all lowercase letters from a to z */
+	static readonly LOWERCASE_LETTERS = "abcdefghijklmnopqrstuvwxyz";
+	/** A string containing all uppercase letters from A to Z */
+	static readonly UPPERCASE_LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+	/** A string containing all numeric digits from 0 to 9 */
+	static readonly NUMBERS = "0123456789";
+	/** A string containing both lowercase and uppercase letters */
+	static readonly LOWERCASE_UPPERCASE: string;
+	/** A string containing all alphanumeric characters (letters and numbers) */
+	static readonly ALPHANUMERIC: string;
+	static generateNonce(): string;
+	static generateString(chars: string, length: number): string;
+	static capitalize<K extends string>(str: K): Capitalize<K>;
+	static count(source: string, target: string): number;
+	static escapeRegExp(string: string): string;
+}
+/**
+ * A collection of some utilities.
+ */
+export declare class Utils {
+	private static readonly NATURAL_COLLATOR;
+	/**
+	 * Returns the contents of the specified url.
+	 *
+	 * If the body of the request is not present,
+	 * then the promise completes with undefined.
+	 * Otherwise, the promise will be completed
+	 * with the read binary data as an ArrayBuffer.
+	 *
+	 * @param url the URL to get
+	 * @param fetchOptions request init data
+	 * @param progressConsumer a callback containing
+	 */
+	static getLargeFile(url: string, fetchOptions: RequestInit, progressConsumer: (read: number, length: number) => void): Promise<ArrayBuffer | undefined>;
+	/**
+	 * Performs a binary search on the specified ordered array for the specified element.
+	 * If the object is found within the array, the index of the element is returned.
+	 *
+	 * Let x be the position at which the element should be placed in the array.
+	 * If the object is not found within the array, this method will return -(x + 1).
+	 * @param array the ordered array to search
+	 * @param element the element to search for
+	 * @param compareFunction the function to use for comparing elements
+	 * @returns the index of the element, or the insertion index
+	 */
+	static binarySearch<T>(array: Array<T>, element: T, compareFunction: (a: T, b: T) => number): number;
+	/**
+	 * Performs a binary search on the specified ordered array for the specified element.
+	 * The element being searched is a property of an element in the array.
+	 * If the object is found within the array, the index of the element is returned.
+	 *
+	 * Let x be the position at which the element should be placed in the array.
+	 * If the object is not found within the array, this method will return -(x + 1).
+	 * @param array the ordered array to search
+	 * @param element the element to search for
+	 * @param compareFunction the function to use for comparing elements
+	 * @param convertFunction the function to use to convert an array element to the searched type
+	 * @returns the index of the element, or the insertion index
+	 */
+	static binarySearch2<T, K>(array: Array<T>, element: K, convertFunction: (element: T) => K, compareFunction: (a: K, b: K) => number): number;
+	/**
+	 * Loads the image at the specified source URL in an asynchronous way.
+	 * @param src the URL to load the image from
+	 * @returns a Future which will complete with an Image object
+	 */
+	static loadImageAsync(src: string): Promise<HTMLImageElement>;
+	/**
+	 * Returns a comparator function using natural sorting
+	 * for the specified type, using the specified string
+	 * extractor function.
+	 * @param func string extractor function
+	 * @template T the original type
+	 * @returns the comparator function
+	 */
+	static naturalComparator<T>(func?: (element: T) => string): (a: T, b: T) => number;
+	/**
+	 * Sorts the array of type T `array` naturally, with
+	 * the string extractor function `func`.
+	 * @param array the array to sort
+	 * @param func the string extractor function
+	 * @returns the same array
+	 * @template T the original type
+	 */
+	static naturalSort<T>(array: T[], func?: (element: T) => string): T[];
+	/**
+	 * Asynchronously sorts an array with a merge sort algorithm, using an async comparator.
+	 * This method is useful when comparison of elements requires asynchronous operations.
+	 * After the Promise returned by this method resolves, the original array will be sorted.
+	 * This same array will be used to resolve the Promise.
+	 *
+	 * @param array the array to be sorted
+	 * @param comparator an async function that compares two elements and returns a Promise
+	 * that resolves to a number (negative if a < b, zero if a = b, positive if a > b)
+	 * @returns a Promise that resolves to the sorted array
+	 */
+	static asyncSort<T>(array: T[], comparator: (a: T, b: T) => Promise<number>): Promise<T[]>;
+	/**
+	 * Compares two arrays and returns the differences between them as added and removed elements.
+	 *
+	 * This method is O(n * m) where n is the length of newArray and m is the length of oldArray
+	 *
+	 * @param newArray The new array to compare
+	 * @param oldArray The old array to compare against
+	 * @param equality Optional function to determine equality between elements.
+	 *                Default compares elements using == operator
+	 * @returns An object containing two arrays:
+	 *          - added: elements present in newArray but not in oldArray
+	 *          - removed: elements present in oldArray but not in newArray
+	 */
+	static diff<T>(newArray: T[], oldArray: T[], equality?: (a: T, b: T) => boolean): {
+		added: T[];
+		removed: T[];
+	};
+	static tableString<T, N extends number>(elements: T[], func: (element: T) => FixedLengthArray<string, N>, options?: TableOptions<N>): string;
+	/**
+	 * Returns an array of string keys from an enum class.
+	 *
+	 * @param enumClass the enum class to get keys from
+	 * @returns array of string keys from the enum
+	 * @template E the enum type with (string or number)
+	 */
+	static getEnumKeys<E extends {
+		[x: string]: string | number;
+	}>(enumClass: {
+		[x: string]: E;
+	}): string[];
+	/**
+	 * Returns an array of enum values/constants from an enum class.
+	 * This method extracts the actual values of the named enum members.
+	 *
+	 * @param enumClass the enum class to get values from
+	 * @returns array of enum values
+	 * @template E the enum type (string or number)
+	 */
+	static getEnumConstants<E extends string | number>(enumClass: {
+		[x: string]: E;
+	}): E[];
+	static presentOrDefault<T>(value: T | undefined, defaultValue: T): T;
+	/**
+	 * Generates a random integer
+	 * between 0 (inclusive) and `to` (exclusive)
+	 *
+	 * `to` will be rounded up to the nearest integer.
+	 * @param to the maximum bound (exclusive)
+	 */
+	static generateRandomInt(to: number): number;
+	/**
+	 * Generates a random integer
+	 * between `from` (inclusive) and `to` (exclusive)
+	 *
+	 * `to` will be rounded up to the nearest integer,
+	 * while `from` will be rounded down to the nearest integer.
+	 * @param from the minimum bound (inclusive)
+	 * @param to the maximum bound (exclusive)
+	 */
+	static generateRandomInt(from: number, to: number): number;
+	/**
+	 * Picks a random character from the
+	 * specified string.
+	 * @param string the string to pick from
+	 * @returns a random character
+	 */
+	static pickRandomElement(string: string): string;
+	/**
+	 * Picks a random element from the
+	 * specified array.
+	 * @param array the array to pick from
+	 * @returns a random element
+	 */
+	static pickRandomElement<T>(array: T[]): T;
+}
+export declare class ZipPluginArchive extends PluginArchive {
+	private zip;
+	constructor(zip: JSZip);
+	protected resolveEntry(path: string): Promise<Blob | null>;
+	getEntries(): Promise<string[]>;
+}
+export declare const DefaultPublicRegistryOptions: {
+	/**
+	 * Whether the local objects in this registry are also proxied.
+	 * This is necessary for classes that do not conform to the
+	 * RegistryObject type, and thus must always be proxied.
+	 *
+	 * Defaults to false.
+	 */
+	localsAreProxied: boolean;
+	/**
+	 * Whether to always verify that this thread actually owns local entries.
+	 *
+	 * Defaults to true.
+	 */
+	verifyLocals: boolean;
+	/**
+	 * Allows shared values in the registry (this means that the ownerThread
+	 * field is allowed to be null). This allows remote registry instances of
+	 * this registry to cache values for shared entries.
+	 *
+	 * In practice, this is only used for the internal meta-registry.
+	 *
+	 * Defaults to false.
+	 */
+	allowShared: boolean;
+};
+export declare const DefaultRegistryOptions: {
+	/**
+	 * Whether the local objects in this registry are also proxied.
+	 * This is necessary for classes that do not conform to the
+	 * RegistryObject type, and thus must always be proxied.
+	 *
+	 * Defaults to false.
+	 */
+	localsAreProxied: boolean;
+	/**
+	 * Whether to always verify that this thread actually owns local entries.
+	 *
+	 * Defaults to true.
+	 */
+	verifyLocals: boolean;
+	/**
+	 * Allows shared values in the registry (this means that the ownerThread
+	 * field is allowed to be null). This allows remote registry instances of
+	 * this registry to cache values for shared entries.
+	 *
+	 * In practice, this is only used for the internal meta-registry.
+	 *
+	 * Defaults to false.
+	 */
+	allowShared: boolean;
+};
+export declare namespace Constructor {
+	/**
+	 * Determines whether a given class type is a subclass of another class type.
+	 *
+	 * @param child the class constructor to check if it is a subclass.
+	 * @param parent the class constructor to act as the parent/superclass.
+	 * @return returns true if the child class is a subclass of the parent class, false otherwise.
+	 *
+	 * @template Child - The child class type
+	 * @template Parent - The parent class type
+	 */
+	function isSubclass<Child, Parent>(child: Constructor<Child>, parent: Constructor<Parent>): Child extends Parent ? true : false;
+}
+export declare namespace Registry {
+	function withDefaultOptions(options?: Partial<RegistryOptions>): RegistryOptions;
+	function withPublicDefaultOptions(options?: Partial<RegistryOptions>): PublicRegistryOptions;
+}
+export interface DevPluginSourceR2SHelloPacket {
+	id: "hello_request";
+	rpackChannel: string;
+	rpackVersion: string;
+	implementationName: string;
+	implementationChannel: string;
+	implementationVersion: string;
+}
+export interface DevPluginSourceR2SPackets {
+	"hello_request": DevPluginSourceR2SHelloPacket;
+}
+export interface DevPluginSourceS2RHelloPacket {
+	id: "hello_response";
+	serverVersion: string;
+	serverBrand: string;
+}
+export interface DevPluginSourceS2RPackets {
+	"hello_response": DevPluginSourceS2RHelloPacket;
+	"plugin_update": DevPluginSourceS2RPluginUpdatePacket;
+}
+export interface DevPluginSourceS2RPluginUpdatePacket {
+	id: "plugin_update";
+	groupId: string;
+	pluginId: string;
+}
+export interface DevPluginSourceServerManifest {
+	rpackDevServer: boolean;
+	protocolVersion: number;
+	brand: string;
+	version: string;
+	websocketRefresh?: boolean;
+}
+export interface H2WHelloRequestPacket extends NoncePacket {
+	id: "thread:hello_request";
+	threadId: string;
+	scriptUrl: string;
+}
+export interface H2WShutdownRequestPacket extends NoncePacket {
+	id: "thread:shutdown_request";
+}
+export interface MultiSetRegistry<Data, Key extends JSONLike = string> extends RegistryBase {
+	append(key: Key, value: Data): Promise<string>;
+	remove(key: Key, value: Data): Promise<boolean>;
+	removeByKey(arrayKey: Key, entryKey: string): Promise<boolean>;
+	get(key: Key): Promise<AsyncIterableIterator<Data> | undefined>;
+	getEntries(key: Key): Promise<AsyncIterableIterator<RegistryEntry<Data, string>> | undefined>;
+	getAllEntriesByThread(ownerThread: string): AsyncIterableIterator<MultiSetRegistryEntry<Data, Key>>;
+	getAllEntries(): AsyncIterableIterator<MultiSetRegistryEntry<Data, Key>>;
+	has(key: string): Promise<boolean>;
+	size(): Promise<number>;
+}
+export interface MultiSetRegistryEntry<Data, Key extends JSONLike> {
+	key: Key;
+	ownerThread: string | null;
+	data: () => AsyncIterableIterator<RegistryDataFiltered<Data>>;
+}
+export interface NoncePacket {
+	nonce: string;
+}
+export interface Packet {
+	id: string;
+}
+export interface PluginManifest {
+	groupId: string;
+	pluginId: string;
+	version: string;
+	authors?: string | string[];
+	name?: string;
+	description?: string;
+	mainClass: string;
+}
+export interface PluginSource {
+	getSourceId(): string;
+	remove(): void;
+	getAllPlugins(): AsyncIterableIterator<PluginManifest>;
+	getPlugin(groupId: string, pluginId: string, version?: string): Promise<PluginManifest | null>;
+	getPluginArchive(groupId: string, pluginId: string, version: string): Promise<PluginArchive>;
+}
+export interface ProxyCleanupPacket {
+	id: "proxy:cleanup";
+	type: ProxyCleanupTarget;
+	key: string;
+}
+export interface ProxyCreateIteratorRequestPacket extends NoncePacket {
+	id: "proxy:create_iterator_request";
+	objectKey: string;
+}
+export interface ProxyCreateIteratorResponsePacket extends NoncePacket {
+	id: "proxy:create_iterator_response";
+	iteratorKey?: string;
+	error?: SerializedData;
+}
+export interface ProxyFunctionRequestPacket extends NoncePacket {
+	id: "proxy:function_request";
+	functionKey: string;
+	args: SerializedData[];
+}
+export interface ProxyFunctionResponsePacket extends NoncePacket {
+	id: "proxy:function_response";
+	value?: SerializedData;
+	error?: SerializedData;
+}
+export interface ProxyIteratorCloseRequestPacket {
+	id: "proxy:iterator_close_request";
+	iteratorKey: string;
+}
+export interface ProxyIteratorNextRequestPacket extends NoncePacket {
+	id: "proxy:iterator_next_request";
+	iteratorKey: string;
+	value?: SerializedData;
+}
+export interface ProxyIteratorNextResponsePacket extends NoncePacket {
+	id: "proxy:iterator_next_response";
+	done?: boolean;
+	value?: SerializedData;
+	error?: SerializedData;
+}
+export interface ProxyMethodRequestPacket extends NoncePacket {
+	id: "proxy:method_request";
+	objectKey: string;
+	method: string;
+	args: SerializedData[];
+}
+export interface ProxyMethodResponsePacket extends NoncePacket {
+	id: "proxy:method_response";
+	value?: SerializedData;
+	error?: SerializedData;
+}
+export interface ProxyPackets {
+	"proxy:refresh_object_request": ProxyRefreshObjectRequestPacket;
+	"proxy:refresh_object_response": ProxyRefreshObjectResponsePacket;
+	"proxy:method_request": ProxyMethodRequestPacket;
+	"proxy:method_response": ProxyMethodResponsePacket;
+	"proxy:function_request": ProxyFunctionRequestPacket;
+	"proxy:function_response": ProxyFunctionResponsePacket;
+	"proxy:create_iterator_request": ProxyCreateIteratorRequestPacket;
+	"proxy:create_iterator_response": ProxyCreateIteratorResponsePacket;
+	"proxy:iterator_next_request": ProxyIteratorNextRequestPacket;
+	"proxy:iterator_next_response": ProxyIteratorNextResponsePacket;
+	"proxy:iterator_close_request": ProxyIteratorCloseRequestPacket;
+	"proxy:cleanup": ProxyCleanupPacket;
+}
+export interface ProxyRefreshObjectRequestPacket extends NoncePacket {
+	id: "proxy:refresh_object_request";
+	objectKey: string;
+}
+export interface ProxyRefreshObjectResponsePacket extends NoncePacket {
+	id: "proxy:refresh_object_response";
+	value?: SerializedData;
+	error?: SerializedData;
+}
+export interface Registry<Data, Key extends JSONLike = string> extends RegistryBase {
+	get(key: Key): Promise<RegistryDataFiltered<Data> | undefined>;
+	getEntry(key: Key): Promise<RegistryEntry<Data, Key> | undefined>;
+	getAllEntriesByThread(ownerThread: string): AsyncIterableIterator<RegistryEntry<Data, Key>>;
+	getAllEntries(): AsyncIterableIterator<RegistryEntry<Data, Key>>;
+	getAll(): AsyncIterableIterator<RegistryDataFiltered<Data>>;
+	has(key: Key): Promise<boolean>;
+	add(key: Key, data: Data): Promise<boolean>;
+	remove(key: Key): Promise<boolean>;
+	size(): Promise<number>;
+}
+export interface RegistryAddRequestPacket extends NoncePacket {
+	id: "registry:add_request";
+	registryId: string;
+	key: JSONLike;
+	ownerThread: string;
+	value: RegistrySerializedData;
+}
+export interface RegistryAddResponsePacket extends NoncePacket {
+	id: "registry:add_response";
+	value?: boolean;
+	error?: SerializedData;
+}
+export interface RegistryBase {
+	getRegistryId(): string;
+	getRegistryManager(): RegistryManager;
+	getOptions(): PublicRegistryOptions;
+}
+export interface RegistryEntry<Data, Key extends JSONLike> {
+	key: Key;
+	ownerThread: string | null;
+	data: RegistryDataFiltered<Data>;
+}
+export interface RegistryGetAllEntriesByThreadRequestPacket extends NoncePacket {
+	id: "registry:get_all_entries_by_thread_request";
+	registryId: string;
+	ownerThread: string;
+}
+export interface RegistryGetAllEntriesByThreadResponsePacket extends NoncePacket {
+	id: "registry:get_all_entries_by_thread_response";
+	iteratorKey?: string;
+	error?: SerializedData;
+}
+export interface RegistryGetAllEntriesRequestPacket extends NoncePacket {
+	id: "registry:get_all_entries_request";
+	registryId: string;
+}
+export interface RegistryGetAllEntriesResponsePacket extends NoncePacket {
+	id: "registry:get_all_entries_response";
+	iteratorKey?: string;
+	error?: SerializedData;
+}
+export interface RegistryGetAllRequestPacket extends NoncePacket {
+	id: "registry:get_all_request";
+	registryId: string;
+}
+export interface RegistryGetAllResponsePacket extends NoncePacket {
+	id: "registry:get_all_response";
+	iteratorKey?: string;
+	error?: SerializedData;
+}
+export interface RegistryGetEntryRequestPacket extends NoncePacket {
+	id: "registry:get_entry_request";
+	registryId: string;
+	key: JSONLike;
+}
+export interface RegistryGetEntryResponsePacket extends NoncePacket {
+	id: "registry:get_entry_response";
+	value?: {
+		key: SerializedData;
+		ownerThread: string | null;
+		data: SerializedData;
+	} | null;
+	error?: SerializedData;
+}
+export interface RegistryGetRequestPacket extends NoncePacket {
+	id: "registry:get_request";
+	registryId: string;
+	key: JSONLike;
+}
+export interface RegistryGetResponsePacket extends NoncePacket {
+	id: "registry:get_response";
+	value?: SerializedData;
+	error?: SerializedData;
+}
+export interface RegistryHasRequestPacket extends NoncePacket {
+	id: "registry:has_request";
+	registryId: string;
+	key: JSONLike;
+}
+export interface RegistryHasResponsePacket extends NoncePacket {
+	id: "registry:has_response";
+	value?: boolean;
+	error?: SerializedData;
+}
+export interface RegistryPackets {
+	"registry:add_request": RegistryAddRequestPacket;
+	"registry:add_response": RegistryAddResponsePacket;
+	"registry:has_request": RegistryHasRequestPacket;
+	"registry:has_response": RegistryHasResponsePacket;
+	"registry:remove_request": RegistryRemoveRequestPacket;
+	"registry:remove_response": RegistryRemoveResponsePacket;
+	"registry:size_request": RegistrySizeRequestPacket;
+	"registry:size_response": RegistrySizeResponsePacket;
+	"registry:get_request": RegistryGetRequestPacket;
+	"registry:get_response": RegistryGetResponsePacket;
+	"registry:get_entry_request": RegistryGetEntryRequestPacket;
+	"registry:get_entry_response": RegistryGetEntryResponsePacket;
+	"registry:get_all_entries_by_thread_request": RegistryGetAllEntriesByThreadRequestPacket;
+	"registry:get_all_entries_by_thread_response": RegistryGetAllEntriesByThreadResponsePacket;
+	"registry:get_all_entries_request": RegistryGetAllEntriesRequestPacket;
+	"registry:get_all_entries_response": RegistryGetAllEntriesResponsePacket;
+	"registry:get_all_request": RegistryGetAllRequestPacket;
+	"registry:get_all_response": RegistryGetAllResponsePacket;
+}
+export interface RegistryRemoveRequestPacket extends NoncePacket {
+	id: "registry:remove_request";
+	registryId: string;
+	key: JSONLike;
+	ownerThread: string;
+}
+export interface RegistryRemoveResponsePacket extends NoncePacket {
+	id: "registry:remove_response";
+	value?: boolean;
+	error?: SerializedData;
+}
+export interface RegistrySizeRequestPacket extends NoncePacket {
+	id: "registry:size_request";
+	registryId: string;
+}
+export interface RegistrySizeResponsePacket extends NoncePacket {
+	id: "registry:size_response";
+	value?: number;
+	error?: SerializedData;
+}
+export interface SerializedError {
+	type: "error";
+	errorType: "Error" | "EvalError" | "RangeError" | "ReferenceError" | "SyntaxError" | "TypeError" | "URIError";
+	name: string;
+	message: string;
+	stack: string | undefined;
+}
+export interface SerializedFunction {
+	type: "function";
+	functionKey: string;
+}
+export interface SerializedJSON {
+	type: "json";
+	value: JSONLike;
+}
+export interface SerializedObject {
+	type: "object";
+	objectKey: string;
+	typeName: string;
+	props: string[];
+	functions: string[];
+	iterable: boolean;
+}
+export interface SerializedRegistry {
+	type: "registry";
+	registryId: string;
+	options: PublicRegistryOptions;
+}
+export interface SerializedRegistryEntry extends Omit<SerializedObject, "type" | "props"> {
+	type: "registry_entry";
+	props: Record<string, SerializedData>;
+}
+export interface SerializedUndefined {
+	type: "undefined";
+}
+export interface SerializedWellKnown {
+	type: "well_known";
+	kind: "RPack" | "NetworkManager" | "ProxyManager" | "RegistryManager";
+}
+export interface SetRegistry<Data> extends RegistryBase {
+	add(value: Data): Promise<string>;
+	remove(value: Data): Promise<boolean>;
+	removeByKey(key: string): Promise<boolean>;
+	getByKey(key: string): Promise<RegistryDataFiltered<Data> | undefined>;
+	getEntryByKey(key: string): Promise<RegistryEntry<Data, string> | undefined>;
+	getAllEntriesByThread(ownerThread: string): AsyncIterableIterator<RegistryEntry<Data, string>>;
+	getAllEntries(): AsyncIterableIterator<RegistryEntry<Data, string>>;
+	getAll(): AsyncIterableIterator<RegistryDataFiltered<Data>>;
+	has(value: Data): Promise<boolean>;
+	hasKey(key: string): Promise<boolean>;
+	size(): Promise<number>;
+}
+export interface TableOptions<N extends number> {
+	separator?: string | string[];
+	headers?: FixedLengthArray<string, N>;
+	padding?: string;
+	textAlign?: "left" | "center" | "right";
+}
+export interface W2HHelloResponsePacket extends NoncePacket {
+	id: "thread:hello_response";
+}
+export interface W2HPluginLoadPacket extends NoncePacket {
+	id: "thread:plugin_load";
+}
+export interface W2HShutdownResponsePacket extends NoncePacket {
+	id: "thread:shutdown_response";
+}
+export type BatchResult<T> = {
+	done: boolean;
+	values: T[];
+};
+/**
+ * A type alias representing a constructor signature for creating instances of type `T`.
+ *
+ * This type can be used to define or constrain the shape of classes or functions
+ * that act as constructors. It accepts an arbitrary number of arguments of any type
+ * and returns an instance of the specified type `T`.
+ *
+ * @template T the type of object that the constructor creates
+ */
+export type Constructor<T> = T extends {
+	new (...args: infer P): infer R;
+} ? {
+	new (...args: P): R;
+} : {
+	new (...args: any[]): T;
+};
+export type DeserializedFilter<T> = Pick<T, {
+	[K in keyof T]: T[K] extends ((...args: infer P) => Promise<Serializable | void>) ? P extends [
+	] ? K : P[number] extends Serializable ? K : never : never;
+}[keyof T]>;
+export type ErrorType = Error | EvalError | RangeError | ReferenceError | SyntaxError | TypeError | URIError;
+export type FixedLengthArray<T, L extends number, TObj = [
+	T,
+	...Array<T>
+]> = TObj & {
+	readonly length: L;
+	[I: number]: T;
+	[Symbol.iterator]: () => IterableIterator<T>;
+};
+export type H2WPackets = {
+	"thread:hello_request": H2WHelloRequestPacket;
+	"thread:shutdown_request": H2WShutdownRequestPacket;
+} & ProxyPackets & RegistryPackets;
+export type JSONLike = string | number | boolean | null | {
+	[key: string]: JSONLike;
+} | JSONLike[];
+export type MappedDeserializedData<T> = T extends SerializedUndefined ? undefined : T extends SerializedJSON ? JSONLike : T extends SerializedRegistry ? Registry<any, any> : T extends SerializedError ? ErrorType : T extends SerializedObject ? SerializableObject : T extends SerializedRegistryEntry ? RegistryObject<any> : T extends SerializedFunction ? SerializableFunction : T extends {
+	"type": "well_known";
+	"kind": "RPack";
+} ? RPack : T extends {
+	"type": "well_known";
+	"kind": "NetworkManager";
+} ? NetworkManager : T extends {
+	"type": "well_known";
+	"kind": "ProxyManager";
+} ? ProxyManager : T extends {
+	"type": "well_known";
+	"kind": "RegistryManager";
+} ? RegistryManager : T extends SerializedWellKnown ? WellKnownType : never;
+export type MappedSerializedData<T> = T extends undefined ? SerializedUndefined : T extends JSONLike ? SerializedJSON : T extends RegistryType ? SerializedRegistry : T extends ErrorType ? SerializedError : T extends SerializableObject ? SerializedObject : T extends SerializableFunction ? SerializedFunction : T extends RPack ? {
+	"type": "well_known";
+	"kind": "RPack";
+} : T extends NetworkManager ? {
+	"type": "well_known";
+	"kind": "NetworkManager";
+} : T extends ProxyManager ? {
+	"type": "well_known";
+	"kind": "ProxyManager";
+} : T extends RegistryManager ? {
+	"type": "well_known";
+	"kind": "RegistryManager";
+} : never;
+export type OnlyNoncePacketTypes<Packets extends PacketsType<Packets>> = {
+	[Key in keyof Packets]: Packets[Key] extends NoncePacket ? Key : never;
+}[keyof Packets];
+export type OnlyNoncePackets<Packets extends PacketsType<Packets>> = {
+	[Key in OnlyNoncePacketTypes<Packets>]: Packets[Key] & NoncePacket;
+};
+export type PacketHandler<T> = (packet: T) => unknown | false;
+export type PacketHandlers<T> = {
+	[Key in keyof T]?: (T[Key] extends void ? () => (void | false) : PacketHandler<T[Key]>)[];
+};
+export type PacketsType<Packets extends Record<string, Packet>> = {
+	[Key in keyof Packets]: Packets[Key];
+};
+export type PromiseFunction<F, K> = F extends (...args: any[]) => PromiseLike<unknown> ? K : never;
+export type PromisesOnly<T> = {
+	[K in keyof T]: PromiseFunction<T[K], K>;
+};
+export type ProxyCleanupTarget = "object" | "iterator" | "array" | "function";
+export type PublicRegistryOptions = typeof DefaultPublicRegistryOptions;
+export type RPackConstructorOptions = {
+	pluginThread: boolean;
+	loadPromise: Promise<void>;
+	platform: RPPlatform;
+	threadId: string;
+	hostMessenger?: Messenger<H2WPackets, W2HPackets>;
+	version: RPVersion;
+};
+export type RegistryDataFiltered<Data> = Data extends Serializable ? Data : {
+	readonly [Key in keyof Data]: Data[Key] extends Serializable ? Data[Key] : Data[Key] extends (...args: any) => Promise<any> ? Data[Key] : Data[Key] extends (...args: infer P) => infer R ? (...args: P) => Promise<R> : never;
+};
+export type RegistryObject<T> = {
+	readonly [Key in keyof T]: Serializable | ((...args: any) => Promise<any>);
+};
+export type RegistryOptions = typeof DefaultRegistryOptions;
+export type RegistrySerializedData = SerializedUndefined | SerializedJSON | SerializedRegistry | SerializedError | SerializedObject | SerializedFunction | SerializedWellKnown | SerializedRegistryEntry;
+export type RegistryType = LocalRegistry<any, any> | Registry<any, any> | RemoteRegistry<any, any>;
+export type RegistryWrapped<T> = Pick<T, PromisesOnly<T>[keyof T]>;
+export type SenderFunction<T> = (packet: T[keyof T]) => void;
+export type Serializable = undefined | JSONLike | RegistryType | ErrorType | WellKnownType | SerializableFunction;
+export type SerializableFunction = (...args: Serializable[]) => Promise<Serializable>;
+export type SerializableObject = Record<string, SerializableFunction>;
+export type SerializedData = SerializedUndefined | SerializedJSON | SerializedRegistry | SerializedError | SerializedObject | SerializedFunction | SerializedWellKnown;
+export type W2HPackets = {
+	"thread:hello_response": W2HHelloResponsePacket;
+	"thread:plugin_load": W2HPluginLoadPacket;
+	"thread:shutdown_response": W2HShutdownResponsePacket;
+} & ProxyPackets & RegistryPackets;
+export type WellKnownType = RPack | NetworkManager | ProxyManager | RegistryManager;
+
+export {
+	RPack as default,
+};
+
+export as namespace RPack;
+