@omujs/omu 0.9.43 → 0.9.47

package/dist/dts/api/endpoint/extension.d.ts

@@ -1,23 +0,0 @@
-import { Omu } from "../../omu";
-import { ExtensionType } from "../extension.js";
-import { EndpointType } from "./endpoint.js";
-import { InvokedParams } from "./packets.js";
-export declare const ENDPOINT_EXTENSION_TYPE: ExtensionType<EndpointExtension>;
-export declare class EndpointExtension {
-	private readonly omu;
-	readonly type: ExtensionType<EndpointExtension>;
-	private readonly boundEndpoints;
-	private readonly responsePromises;
-	private callId;
-	constructor(omu: Omu);
-	private handleInvoked;
-	private onTask;
-	bind<
-		Req,
-		Res
-	>(type: EndpointType<Req, Res>, handler: (data: Req, params: InvokedParams) => Promise<Res>): void;
-	call<
-		Req,
-		Res
-	>(endpoint: EndpointType<Req, Res>, data: Req): Promise<Res>;
-}

package/dist/dts/api/endpoint/index.d.ts

@@ -1,2 +0,0 @@
-export { EndpointType } from "./endpoint.js";
-export type { InvokedParams, InvokeParams } from "./packets.js";

package/dist/dts/api/endpoint/packets.d.ts

@@ -1,51 +0,0 @@
-import { Identifier, IdentifierMap } from "../../identifier";
-export declare class EndpointRegisterPacket {
-	endpoints: IdentifierMap<Identifier | undefined>;
-	constructor(endpoints: IdentifierMap<Identifier | undefined>);
-	static serialize(item: EndpointRegisterPacket): Uint8Array;
-	static deserialize(item: Uint8Array): EndpointRegisterPacket;
-}
-export declare class InvokedParams {
-	readonly id: Identifier;
-	readonly caller: Identifier;
-	readonly key: number;
-	constructor(id: Identifier, caller: Identifier, key: number);
-	static serialize(item: InvokedParams): string;
-	static deserialize(item: string): InvokedParams;
-}
-export declare class EndpointInvokedPacket {
-	params: InvokedParams;
-	buffer: Uint8Array;
-	constructor(params: InvokedParams, buffer: Uint8Array);
-	static serialize(item: EndpointInvokedPacket): Uint8Array;
-	static deserialize(item: Uint8Array): EndpointInvokedPacket;
-}
-export declare class InvokeParams {
-	readonly id: Identifier;
-	readonly key: number;
-	constructor(id: Identifier, key: number);
-	static serialize(item: InvokeParams): string;
-	static deserialize(item: string): InvokeParams;
-}
-export declare class EndpointInvokePacket {
-	params: InvokeParams;
-	buffer: Uint8Array;
-	constructor(params: InvokeParams, buffer: Uint8Array);
-	static serialize(item: EndpointInvokePacket): Uint8Array;
-	static deserialize(item: Uint8Array): EndpointInvokePacket;
-}
-export declare class ResponseParams {
-	readonly id: Identifier;
-	readonly key: number;
-	readonly error: string | null;
-	constructor(id: Identifier, key: number, error: string | null);
-	static serialize(item: ResponseParams): string;
-	static deserialize(item: string): ResponseParams;
-}
-export declare class EndpointResponsePacket {
-	params: ResponseParams;
-	buffer: Uint8Array;
-	constructor(params: ResponseParams, buffer: Uint8Array);
-	static serialize(item: EndpointResponsePacket): Uint8Array;
-	static deserialize(item: Uint8Array): EndpointResponsePacket;
-}

package/dist/dts/api/extension-registry.d.ts

@@ -1,8 +0,0 @@
-import { Omu } from "../omu.js";
-import type { Extension, ExtensionType } from "./extension.js";
-export declare class ExtensionRegistry {
-	private readonly omu;
-	private readonly extensionMap;
-	constructor(omu: Omu);
-	register<T extends Extension>(type: ExtensionType<T>): T;
-}

package/dist/dts/api/extension.d.ts

@@ -1,11 +0,0 @@
-import { Identifier } from "../identifier";
-import { Omu } from "../omu";
-export interface Extension {
-	readonly type: ExtensionType;
-}
-export declare class ExtensionType<T extends Extension = Extension> extends Identifier {
-	readonly name: string;
-	readonly create: (omu: Omu) => T;
-	constructor(name: string, create: (omu: Omu) => T);
-	key(): string;
-}

package/dist/dts/api/http/extension.d.ts

@@ -1,41 +0,0 @@
-import { Identifier } from "../../identifier";
-import { Omu } from "../../omu";
-import { Extension, ExtensionType } from "../extension";
-import { OmuResponse, RequestHandle } from "./http";
-import { OmuWS } from "./websocket";
-export declare const HTTP_EXTENSION_TYPE: ExtensionType<HttpExtension>;
-export declare const HTTP_REQUEST_PERMISSION_ID: Identifier;
-type HttpResponse = RequestHandle & {
-	header: Record<string, string>;
-	status: number;
-	statusText: string;
-	url: string;
-	history: HttpResponse[];
-	redirected: boolean;
-};
-export declare class HttpExtension implements Extension {
-	private readonly omu;
-	readonly type: ExtensionType<Extension>;
-	private requestCount;
-	private readonly httpHandles;
-	private readonly wsHandles;
-	private readonly wsSendQueue;
-	private wsSendWaitResolve;
-	constructor(omu: Omu);
-	private wsSendLoop;
-	private generateHeaders;
-	private generateId;
-	request(input: string | URL | globalThis.Request, init?: RequestInit): Promise<{
-		response: HttpResponse;
-		stream: ReadableStream;
-	}>;
-	fetch(input: string | URL | globalThis.Request, init?: RequestInit): Promise<OmuResponse>;
-	ws(input: string | URL | globalThis.Request, options?: {
-		method?: string;
-		autoclose?: boolean;
-		autoping?: boolean;
-		params?: Record<string, string>;
-		headers?: Record<string, string>;
-	}): Promise<OmuWS>;
-}
-export {};

package/dist/dts/api/http/http.d.ts

@@ -1,36 +0,0 @@
-import { JsonType } from "../../serialize";
-export type RequestHandle = {
-	id: string;
-};
-export type HttpRequest = RequestHandle & {
-	header: Record<string, string>;
-	method: string;
-	redirect: RequestRedirect;
-	url: string;
-};
-export declare class DataChunk<T extends JsonType> {
-	readonly meta: T;
-	readonly body: Uint8Array;
-	constructor(meta: T, body: Uint8Array);
-	static serialize<T extends JsonType>(data: DataChunk<T>): Uint8Array;
-	static deserialize<T extends JsonType>(data: Uint8Array): DataChunk<T>;
-}
-export declare class OmuResponse implements Response {
-	readonly headers: Headers;
-	readonly ok: boolean;
-	readonly redirected: boolean;
-	readonly status: number;
-	readonly statusText: string;
-	readonly type: ResponseType;
-	readonly url: string;
-	readonly body: ReadableStream<Uint8Array<ArrayBuffer>> | null;
-	readonly bodyUsed: boolean;
-	constructor(headers: Headers, ok: boolean, redirected: boolean, status: number, statusText: string, type: ResponseType, url: string, body: ReadableStream<Uint8Array<ArrayBuffer>> | null, bodyUsed: boolean);
-	clone(): OmuResponse;
-	arrayBuffer(): Promise<ArrayBuffer>;
-	blob(): Promise<Blob>;
-	bytes(): Promise<Uint8Array<ArrayBuffer>>;
-	formData(): Promise<FormData>;
-	json(): Promise<any>;
-	text(): Promise<string>;
-}

package/dist/dts/api/http/index.d.ts

@@ -1,2 +0,0 @@
-export { HTTP_REQUEST_PERMISSION_ID } from "./extension";
-export { OmuWS, type WSMsg } from "./websocket";

package/dist/dts/api/http/websocket.d.ts

@@ -1,123 +0,0 @@
-import { DataChunk, RequestHandle } from "./http";
-export type WSData = string | ArrayBufferLike | Blob | ArrayBufferView;
-export declare const WSMsgType: {
-	readonly CONTINUATION: 0x0;
-	readonly TEXT: 0x1;
-	readonly BINARY: 0x2;
-	readonly PING: 0x9;
-	readonly PONG: 0xA;
-	readonly CLOSE: 0x8;
-};
-export declare const WSCloseCode: {
-	readonly OK: 1000;
-	readonly GOING_AWAY: 1001;
-	readonly PROTOCOL_ERROR: 1002;
-	readonly UNSUPPORTED_DATA: 1003;
-	readonly ABNORMAL_CLOSURE: 1006;
-	readonly INVALID_TEXT: 1007;
-	readonly POLICY_VIOLATION: 1008;
-	readonly MESSAGE_TOO_BIG: 1009;
-	readonly MANDATORY_EXTENSION: 1010;
-	readonly INTERNAL_ERROR: 1011;
-	readonly SERVICE_RESTART: 1012;
-	readonly TRY_AGAIN_LATER: 1013;
-	readonly BAD_GATEWAY: 1014;
-};
-export type WebSocketOpen = RequestHandle & {
-	url: string;
-	protocol?: string | null;
-};
-export type WebSocketClose = RequestHandle & {
-	code?: number;
-	reason?: string | null;
-};
-export type WebSocketError = RequestHandle & {
-	type: "ConnectionRefused";
-	reason?: string | null;
-};
-export type EventListenerMap<T> = { [K in keyof T] : ((event: T[K]) => unknown)[] };
-export type WSMsg = {
-	type: "open";
-	data: WebSocketOpen;
-} | {
-	type: "error";
-	data: WebSocketError;
-} | {
-	type: "text";
-	data: string;
-} | {
-	type: "binary";
-	data: Uint8Array;
-} | {
-	type: "close";
-	data: WebSocketClose;
-};
-export type WebSocketHandle = {
-	ws: OmuWS;
-	open: (response: WebSocketOpen) => void;
-	dispatch: (data: DataChunk<WSDataMeta>) => void;
-	close: (response: WebSocketClose) => void;
-	error: (response: WebSocketError) => void;
-};
-export type WSDataMeta = {
-	id: string;
-	type: typeof WSMsgType.TEXT | typeof WSMsgType.BINARY | typeof WSMsgType.PING | typeof WSMsgType.PONG;
-};
-export type WSHandleState = {
-	type: "created" | "receiving";
-	handle: WebSocketHandle;
-};
-type WSOptions = {
-	addQueue: (data: WSData) => void;
-	dispose(options: {
-		code?: number;
-		reason?: string;
-	}): void;
-};
-export declare class OmuWS {
-	protected readonly addQueue: (data: WSData) => void;
-	protected readonly dispose: (options: {
-		code?: number;
-		reason?: string;
-	}) => void;
-	protected readonly receiveQueue: WSMsg[];
-	private receiveResolve;
-	private status;
-	constructor(addQueue: (data: WSData) => void, dispose: (options: {
-		code?: number;
-		reason?: string;
-	}) => void, receiveQueue?: WSMsg[], receiveResolve?: (() => void) | undefined, status?: "connecting" | "open" | "closed");
-	toWebSocket(): OmuWebSocket;
-	static create(options: WSOptions): WebSocketHandle;
-	send(data: WSData): void;
-	close(code?: number, reason?: string): void;
-	receive(): Promise<WSMsg>;
-	protocol: string;
-	url: string;
-}
-export declare class OmuWebSocket implements WebSocket {
-	protected readonly ws: OmuWS;
-	private readonly eventListeners;
-	CONNECTING: 0;
-	OPEN: 1;
-	CLOSING: 2;
-	CLOSED: 3;
-	binaryType: BinaryType;
-	bufferedAmount: number;
-	extensions: string;
-	onclose: ((this: WebSocket, ev: CloseEvent) => unknown) | null;
-	onerror: ((this: WebSocket, ev: Event) => unknown) | null;
-	onmessage: ((this: WebSocket, ev: MessageEvent) => unknown) | null;
-	onopen: ((this: WebSocket, ev: Event) => unknown) | null;
-	protocol: string;
-	readyState: 0 | 2 | 1 | 3;
-	url: string;
-	constructor(ws: OmuWS, eventListeners?: EventListenerMap<WebSocketEventMap>);
-	private receiveLoop;
-	dispatchEvent(event: Event): boolean;
-	send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
-	close(code?: number, reason?: string): void;
-	addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => unknown): void;
-	removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => unknown): void;
-}
-export {};

package/dist/dts/api/i18n/extension.d.ts

@@ -1,19 +0,0 @@
-import { Identifier } from "../../identifier";
-import type { Locale } from "../../localization/locale.js";
-import type { LocalizedText } from "../../localization/localization.js";
-import { Omu } from "../../omu";
-import type { Extension } from "../extension.js";
-import { ExtensionType } from "../extension.js";
-import { type Registry } from "../registry";
-export declare const I18N_EXTENSION_TYPE: ExtensionType<I18nExtension>;
-export declare const I18N_SET_LOCALES_PERMISSION_ID: Identifier;
-export declare const I18N_GET_LOCALES_PERMISSION_ID: Identifier;
-export declare class I18nExtension implements Extension {
-	private readonly omu;
-	readonly type: ExtensionType<I18nExtension>;
-	readonly localesRegistry: Registry<Locale[]>;
-	constructor(omu: Omu);
-	translate(localizedText: LocalizedText): string;
-	selectBestTranslation(locales: readonly Locale[], localizedText: LocalizedText): string | undefined;
-	setLocale(locale: Locale[]): Promise<void>;
-}

package/dist/dts/api/i18n/index.d.ts

@@ -1 +0,0 @@
-export { I18N_GET_LOCALES_PERMISSION_ID, I18N_SET_LOCALES_PERMISSION_ID } from "./extension.js";

package/dist/dts/api/index.d.ts

@@ -1,2 +0,0 @@
-export { ExtensionRegistry } from "./extension-registry.js";
-export { Extension, ExtensionType } from "./extension.js";

package/dist/dts/api/logger/extension.d.ts

@@ -1,25 +0,0 @@
-import type { Unlisten } from "../../event";
-import { Identifier } from "../../identifier";
-import { PacketType } from "../../network/packet/packet.js";
-import { Omu } from "../../omu";
-import { ExtensionType } from "../extension.js";
-import type { LogMessage } from "./packets.js";
-import { LogPacket } from "./packets.js";
-export declare const LOGGER_EXTENSION_TYPE: ExtensionType<LoggerExtension>;
-export declare const LOGGER_LOG_PERMISSION_ID: Identifier;
-export declare const LOGGER_LOG_PACKET: PacketType<LogPacket>;
-export declare const LOGGER_LISTEN_PACKET: PacketType<Identifier>;
-type LogListener = (message: LogMessage) => void;
-export declare class LoggerExtension {
-	private readonly omu;
-	readonly type: ExtensionType<LoggerExtension>;
-	private readonly listeners;
-	constructor(omu: Omu);
-	log(message: LogMessage): void;
-	error(text: string): void;
-	warning(text: string): void;
-	info(text: string): void;
-	debug(text: string): void;
-	listen(id: Identifier, listener: LogListener): Unlisten;
-}
-export {};

package/dist/dts/api/logger/index.d.ts

@@ -1 +0,0 @@
-export { LOGGER_LOG_PERMISSION_ID } from "./extension.js";

package/dist/dts/api/logger/packets.d.ts

@@ -1,18 +0,0 @@
-import { Identifier } from "../../identifier";
-export declare enum LogType {
-	ERROR = "error",
-	WARNING = "warning",
-	INFO = "info",
-	DEBUG = "debug"
-}
-export type LogMessage = {
-	type: LogType;
-	text: string;
-};
-export declare class LogPacket {
-	readonly id: Identifier;
-	readonly message: LogMessage;
-	constructor(id: Identifier, message: LogMessage);
-	static serialize(item: LogPacket): Uint8Array;
-	static deserialize(item: Uint8Array): LogPacket;
-}

package/dist/dts/api/permission/extension.d.ts

@@ -1,19 +0,0 @@
-import { Identifier, IntoId } from "../../identifier";
-import { Omu } from "../../omu";
-import { ExtensionType } from "../extension.js";
-import { PermissionType } from "./permission.js";
-export declare const PERMISSION_EXTENSION_TYPE: ExtensionType<PermissionExtension>;
-export declare class PermissionExtension {
-	private readonly omu;
-	readonly type: ExtensionType<PermissionExtension>;
-	private permissions;
-	private readonly registeredPermissions;
-	private readonly requiredPermissions;
-	constructor(omu: Omu);
-	private onTask;
-	register(permission: PermissionType): void;
-	require(...permissionIds: IntoId[]): void;
-	request(...permissionIds: Identifier[]): Promise<void>;
-	has(permissionIdentifier: Identifier): boolean;
-	required(permissionIdentifier: Identifier): boolean;
-}

package/dist/dts/api/permission/index.d.ts

@@ -1 +0,0 @@
-export { PermissionType, type PermissionLevel, type PermissionMetadata } from "./permission.js";

package/dist/dts/api/permission/permission.d.ts

@@ -1,25 +0,0 @@
-import { Identifier, IntoId } from "../../identifier";
-import type { LocalizedText } from "../../localization/localization.js";
-export type PermissionLevel = "low" | "medium" | "high";
-export type PermissionMetadata = {
-	name: LocalizedText;
-	note?: LocalizedText;
-	level: PermissionLevel;
-};
-export type PermissionTypeJson = {
-	id: string;
-	metadata: PermissionMetadata;
-};
-export declare class PermissionType {
-	readonly id: Identifier;
-	readonly metadata: PermissionMetadata;
-	constructor(options: {
-		id: Identifier;
-		metadata: PermissionMetadata;
-	});
-	static create(identifier: IntoId, { metadata }: {
-		metadata: PermissionMetadata;
-	}): PermissionType;
-	static serialize(data: PermissionType): PermissionTypeJson;
-	static deserialize(json: PermissionTypeJson): PermissionType;
-}

package/dist/dts/api/plugin/extension.d.ts

@@ -1,43 +0,0 @@
-import { Identifier } from "../../identifier";
-import { Omu } from "../../omu";
-import { ExtensionType } from "../extension.js";
-import { Table } from "../table/table.js";
-export declare const PLUGIN_EXTENSION_TYPE: ExtensionType<PluginExtension>;
-export declare class PluginExtension {
-	private readonly omu;
-	readonly type: ExtensionType<PluginExtension>;
-	private readonly requiredPlugins;
-	constructor(omu: Omu);
-	getAllowedPackages(): Table<PluginPackageInfo>;
-	reload(options: ReloadOptions): void;
-	private onTask;
-	require(plugins: Record<string, string | null>): void;
-}
-export declare class PluginPackageInfo {
-	package: string;
-	version: string;
-	constructor(_package: string, version: string);
-	static serialize(data: PluginPackageInfo): {
-		package: string;
-		version: string;
-	};
-	static deserialize(data: {
-		package: string;
-		version: string;
-	}): PluginPackageInfo;
-	static fromJson(json: {
-		package: string;
-		version: string;
-	}): PluginPackageInfo;
-	toJson(): {
-		package: string;
-		version: string;
-	};
-	key(): string;
-}
-export declare const PLUGIN_READ_PACKAGE_PERMISSION_ID: Identifier;
-export declare const PLUGIN_MANAGE_PACKAGE_PERMISSION_ID: Identifier;
-type ReloadOptions = {
-	packages: string[] | null;
-};
-export {};

package/dist/dts/api/plugin/index.d.ts

@@ -1,2 +0,0 @@
-export { PLUGIN_MANAGE_PACKAGE_PERMISSION_ID, PLUGIN_READ_PACKAGE_PERMISSION_ID, PluginPackageInfo } from "./extension.js";
-export type { PackageInfo } from "./package-info.js";

package/dist/dts/api/plugin/package-info.d.ts

@@ -1,84 +0,0 @@
-export type Downloads = {
-	last_day: number;
-	last_month: number;
-	last_week: number;
-};
-export type ProjectUrls = {
-	"Bug Reports": string;
-	"Funding": string;
-	"Homepage": string;
-	"Say Thanks!": string;
-	"Source": string;
-};
-export type Info = {
-	author: string;
-	author_email: string;
-	bugtrack_url: string | null;
-	classifiers: string[];
-	description: string;
-	description_content_type: "text/markdown";
-	docs_url: string | null;
-	download_url: string;
-	downloads: Downloads;
-	home_page: string;
-	keywords: string;
-	license: string;
-	maintainer: string;
-	maintainer_email: string;
-	name: string;
-	package_url: string;
-	platform: unknown;
-	project_url: string;
-	project_urls: ProjectUrls;
-	release_url: string;
-	requires_dist: string[];
-	requires_python: string;
-	summary: string;
-	version: string;
-	yanked: boolean;
-	yanked_reason: string | null;
-};
-export type Digests = {
-	blake2b_256: string;
-	md5: string;
-	sha256: string;
-};
-export type ReleasesItem = {
-	comment_text: string;
-	digests: Digests;
-	downloads: string;
-	filename: string;
-	has_sig: boolean;
-	md5_digest: string;
-	packagetype: string;
-	python_version: string;
-	requires_python: string | null;
-	size: number;
-	upload_time: string;
-	upload_time_iso_8601: string;
-	url: string;
-	yanked: boolean;
-	yanked_reason: string | null;
-};
-export type Releases = {
-	[key: string]: ReleasesItem[];
-};
-export type Urls = ReleasesItem[];
-export type VulnerabilitiesItem = {
-	aliases: string[];
-	details: string;
-	summary: string;
-	fixed_in: string[];
-	id: string;
-	link: string;
-	source: string;
-	withdrawn: string | null;
-};
-export type Vulnerabilities = VulnerabilitiesItem[];
-export type PackageInfo = {
-	info: Info;
-	last_serial: number;
-	releases: Releases;
-	urls: Urls;
-	vulnerabilities: Vulnerabilities;
-};

package/dist/dts/api/registry/extension.d.ts

@@ -1,26 +0,0 @@
-import { Identifier } from "../../identifier";
-import { Omu } from "../../omu";
-import { JsonType, Serializer } from "../../serialize";
-import { type Extension, ExtensionType } from "../extension.js";
-import { type Registry, RegistryType } from "./registry.js";
-export declare class RegistryExtension implements Extension {
-	private readonly omu;
-	readonly type: ExtensionType<RegistryExtension>;
-	private readonly registries;
-	constructor(omu: Omu);
-	private createRegistry;
-	get<T>(registryType: RegistryType<T>): Registry<T>;
-	json<
-		T,
-		D extends JsonType = JsonType
-	>(name: string, options: {
-		default: T;
-		serializer?: Serializer<T, D>;
-	}): Registry<T>;
-	serialized<T>(name: string, options: {
-		default: T;
-		serializer: Serializer<T, Uint8Array>;
-	}): Registry<T>;
-}
-export declare const REGISTRY_EXTENSION_TYPE: ExtensionType<RegistryExtension>;
-export declare const REGISTRY_PERMISSION_ID: Identifier;

package/dist/dts/api/registry/index.d.ts

@@ -1,2 +0,0 @@
-export { REGISTRY_PERMISSION_ID } from "./extension.js";
-export { RegistryType, type Registry, type RegistryPermissions } from "./registry.js";

package/dist/dts/api/registry/packets.d.ts

@@ -1,20 +0,0 @@
-import { Identifier } from "../../identifier";
-import { RegistryPermissions, RegistryPermissionsJSON } from "./registry";
-export declare class RegistryPacket {
-	readonly id: Identifier;
-	readonly value: Uint8Array | null;
-	constructor(id: Identifier, value: Uint8Array | null);
-	static serialize(packet: RegistryPacket): Uint8Array;
-	static deserialize(data: Uint8Array): RegistryPacket;
-}
-export interface RegisterPacketJSON {
-	id: string;
-	permissions: RegistryPermissionsJSON;
-}
-export declare class RegisterPacket {
-	readonly id: Identifier;
-	readonly permissions: RegistryPermissions;
-	constructor(id: Identifier, permissions: RegistryPermissions);
-	static serialize(packet: RegisterPacket): RegisterPacketJSON;
-	static deserialize(data: RegisterPacketJSON): RegisterPacket;
-}

package/dist/dts/api/registry/registry.d.ts

@@ -1,57 +0,0 @@
-import type { Unlisten } from "../../event";
-import { Identifier, IntoId } from "../../identifier";
-import type { JsonType, Serializable } from "../../serialize";
-export interface RegistryPermissionsJSON {
-	all?: string;
-	read?: string;
-	write?: string;
-}
-export interface RegistryPermissions {
-	all?: IntoId;
-	read?: IntoId;
-	write?: IntoId;
-}
-export declare class RegistryType<T> {
-	readonly id: Identifier;
-	readonly defaultValue: T;
-	readonly serializer: Serializable<T, Uint8Array>;
-	readonly permissions: RegistryPermissions;
-	constructor(id: Identifier, defaultValue: T, serializer: Serializable<T, Uint8Array>, permissions: RegistryPermissions);
-	static createJson<
-		T,
-		D extends JsonType = JsonType
-	>(identifier: IntoId, { name, defaultValue, permissions, serializer }: {
-		name: string;
-		defaultValue: T;
-		permissions?: RegistryPermissions;
-		serializer?: Serializable<T, D>;
-	}): RegistryType<T>;
-	static createSerialized<T>(identifier: IntoId, { name, defaultValue, serializer, permissions }: {
-		name: string;
-		defaultValue: T;
-		serializer: Serializable<T, Uint8Array>;
-		permissions?: RegistryPermissions;
-	}): RegistryType<T>;
-}
-export interface Registry<T> {
-	readonly type: RegistryType<T>;
-	readonly value: T;
-	get(): Promise<T>;
-	set(value: T): Promise<void>;
-	update(fn: (value: T) => PromiseLike<T> | T): Promise<T>;
-	modify(fn: (value: T) => PromiseLike<void> | void): Promise<T>;
-	listen(fn: (value: T) => void): Unlisten;
-	compatSvelte(): Writable<T>;
-}
-export type Subscriber<T> = (value: T) => void;
-export type Unsubscriber = () => void;
-export type Updater<T> = (value: T) => T;
-export type StartStopNotifier<T> = (set: (value: T) => void, update: (fn: Updater<T>) => void) => void | (() => void);
-export interface Readable<T> {
-	subscribe(this: void, run: Subscriber<T>): Unsubscriber;
-}
-export interface Writable<T> extends Readable<T> {
-	set(this: void, value: T): void;
-	update(this: void, updater: Updater<T>): void;
-	wait(): Promise<T>;
-}