@omujs/omu 0.9.9 → 0.9.26

package/dist/dts/localization/localization.d.ts

@@ -1,8 +1,5 @@
-import type { Locale } from './locale.js';
-export type LocalizedText = {
-    [key in Locale]?: string;
-} | string;
+import type { Locale } from "./locale.js";
+export type LocalizedText = { [key in Locale]? : string } | string;
 export interface Translations {
-    [key: string]: Translations | LocalizedText;
+	[key: string]: Translations | LocalizedText;
 }
-//# sourceMappingURL=localization.d.ts.map

package/dist/dts/lock.d.ts

@@ -0,0 +1,6 @@
+export declare class Lock {
+	private tasks;
+	private waiter;
+	private wait;
+	use<T>(callback: () => Promise<T>): Promise<T>;
+}

package/dist/dts/network/connection.d.ts

@@ -1,17 +1,17 @@
-import type { Serializable } from '../serializer.js';
-import type { PacketData, PacketType } from './packet/index.js';
-import type { Packet } from './packet/packet.js';
+import type { Serializable } from "../serialize";
+import type { Packet, PacketData, PacketType } from "./packet";
 export declare class PacketMapper implements Serializable<Packet, PacketData> {
-    private readonly packetMap;
-    register(...packetTypes: PacketType<unknown>[]): void;
-    serialize(packet: Packet): PacketData;
-    deserialize(data: PacketData): Packet;
+	private readonly packetMap;
+	register(...packetTypes: PacketType<unknown>[]): void;
+	serialize(packet: Packet): PacketData;
+	deserialize(data: PacketData): Packet;
+}
+export interface Transport {
+	connect(): Promise<Connection>;
 }
 export interface Connection {
-    connect(): Promise<void>;
-    send(packet: Packet, serializer: Serializable<Packet, PacketData>): void;
-    receive(serializer: Serializable<Packet, PacketData>): Promise<Packet | null>;
-    close(): void;
-    closed: boolean;
+	send(packet: Packet, serializer: Serializable<Packet, PacketData>): void;
+	receive(serializer: Serializable<Packet, PacketData>): Promise<Packet | null>;
+	close(): void;
+	closed: boolean;
 }
-//# sourceMappingURL=connection.d.ts.map

package/dist/dts/network/encryption.d.ts

@@ -0,0 +1,38 @@
+import { Packet, PacketData } from "./packet";
+type RSANumbers = {
+	e: string;
+	n: string;
+};
+export type EncryptionResponse = {
+	kind: "v1";
+	rsa: RSANumbers;
+	aes: string;
+};
+export declare const ENCRYPTION_AVAILABLE: boolean;
+export declare class Decryptor {
+	private readonly privateKey;
+	private readonly publicKey;
+	private constructor();
+	static new(): Promise<Decryptor>;
+	toRequest(): Promise<RSANumbers>;
+	decrypt(data: ArrayBuffer): Promise<ArrayBuffer>;
+	decryptString(data: string): Promise<string>;
+}
+export declare class Encryptor {
+	private readonly publicKey;
+	private constructor();
+	static new(request: RSANumbers): Promise<Encryptor>;
+	encrypt(data: ArrayBuffer): Promise<ArrayBuffer>;
+	encryptString(data: string): Promise<string>;
+}
+export declare class AES {
+	private readonly key;
+	private readonly iv;
+	private constructor();
+	static new(): Promise<AES>;
+	static deserialize(aes: string, decryptor: Decryptor): Promise<AES>;
+	serialize(encryptor: Encryptor): Promise<string>;
+	encrypt(data: PacketData): Promise<Packet>;
+	decrypt(packet: Packet<Uint8Array>): Promise<PacketData>;
+}
+export {};

package/dist/dts/network/frame-transport.d.ts

@@ -0,0 +1,22 @@
+import type { Serializable } from "../serialize";
+import type { Connection, Transport } from "./connection.js";
+import type { Packet, PacketData } from "./packet/packet.js";
+export declare class FrameTransport implements Transport {
+	connect(): Promise<FrameConnection>;
+}
+export declare class FrameConnection implements Connection {
+	private connectedWaiter;
+	connected: boolean;
+	private origin;
+	private readonly packetQueue;
+	private readonly sendQueue;
+	private receiveWaiter;
+	constructor(connectedWaiter: (() => void) | null);
+	static create(): Promise<FrameConnection>;
+	private handleCommand;
+	private postCommand;
+	receive(serializer: Serializable<Packet<unknown>, PacketData>): Promise<Packet | null>;
+	get closed(): boolean;
+	close(): void;
+	send(packet: Packet, serializer: Serializable<Packet<unknown>, PacketData>): void;
+}

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

@@ -1,4 +1,5 @@
-export type { Address } from '../address.js';
-export type { Connection } from './connection.js';
-export { Network, NetworkStatus } from './network.js';
-//# sourceMappingURL=index.d.ts.map
+export type { Address } from "../address.js";
+export type { Connection } from "./connection.js";
+export { FrameTransport } from "./frame-transport.js";
+export { Network, type NetworkStatus } from "./network.js";
+export { WebsocketTransport } from "./websocket-transport.js";

package/dist/dts/network/network.d.ts

@@ -1,57 +1,58 @@
-import type { Address } from '../address.js';
-import type { Client } from '../client.js';
-import type { OmuError } from '../errors.js';
-import { EventEmitter } from '../event-emitter.js';
-import type { TokenProvider } from '../token.js';
-import type { Connection } from './connection.js';
-import type { DisconnectPacket } from './packet/packet-types.js';
-import type { Packet, PacketType } from './packet/packet.js';
+import type { Address } from "../address.js";
+import { DisconnectReason } from "../errors.js";
+import { EventEmitter } from "../event";
+import { Omu } from "../omu.js";
+import type { TokenProvider } from "../token.js";
+import type { Connection, Transport } from "./connection.js";
+import { AES } from "./encryption.js";
+import type { Packet, PacketType } from "./packet/packet.js";
 type StatusType<T> = {
-    type: T;
+	type: T;
 };
-export type NetworkStatus = StatusType<'connecting'> | StatusType<'connected'> | StatusType<'ready'> | {
-    type: 'disconnected';
-    attempt?: number;
-    reason?: DisconnectPacket | null;
+export type NetworkStatus = StatusType<"connecting"> | StatusType<"connected"> | StatusType<"ready"> | {
+	type: "disconnected";
+	attempt?: number;
+	reason?: DisconnectReason;
 } | {
-    type: 'error';
-    error: OmuError;
-} | {
-    type: 'reconnecting';
-    attempt: number;
-    timeout: number;
-    date: Date;
-    cancel: () => void;
-} | StatusType<'closed'>;
+	type: "reconnecting";
+	attempt: number;
+	timeout: number;
+	date: Date;
+	cancel: () => void;
+};
 export declare class Network {
-    private readonly client;
-    readonly address: Address;
-    private readonly tokenProvider;
-    private connection;
-    status: NetworkStatus;
-    readonly event: {
-        connected: EventEmitter<[]>;
-        disconnected: EventEmitter<[DisconnectPacket | null]>;
-        packet: EventEmitter<[Packet<unknown>]>;
-        status: EventEmitter<[NetworkStatus]>;
-    };
-    private readonly tasks;
-    private readonly packetMapper;
-    private readonly packetHandlers;
-    constructor(client: Client, address: Address, tokenProvider: TokenProvider, connection: Connection);
-    setConnection(connection: Connection): void;
-    registerPacket(...packetTypes: PacketType<unknown>[]): void;
-    addPacketHandler<T>(type: PacketType<T>, handler: (packet: T) => void): void;
-    private scheduleReconnect;
-    connect(recconect?: boolean): Promise<void>;
-    private isState;
-    send(packet: Packet): void;
-    private listen;
-    private dispatchPacket;
-    addTask(task: () => Promise<void> | void): void;
-    removeTask(task: () => Promise<void> | void): void;
-    private dispatchTasks;
-    private setStatus;
+	private readonly omu;
+	address: Address;
+	private readonly tokenProvider;
+	private transport;
+	private connection?;
+	private aes?;
+	status: NetworkStatus;
+	readonly event: {
+		connected: EventEmitter<[]>;
+		disconnected: EventEmitter<[DisconnectReason | undefined]>;
+		packet: EventEmitter<[Packet<unknown>]>;
+		status: EventEmitter<[NetworkStatus]>;
+	};
+	private readonly tasks;
+	private readonly packetMapper;
+	private readonly packetHandlers;
+	private listenTask;
+	reason: DisconnectReason | undefined;
+	private attempt;
+	constructor(omu: Omu, address: Address, tokenProvider: TokenProvider, transport: Transport, connection?: Connection | undefined, aes?: AES | undefined);
+	setConnection(connection: Connection): void;
+	registerPacket(...packetTypes: PacketType<unknown>[]): void;
+	addPacketHandler<T>(type: PacketType<T>, handler: (packet: T) => void): void;
+	private scheduleReconnect;
+	connect(reconnect?: boolean): Promise<void>;
+	private isState;
+	send(packet: Packet): Promise<void>;
+	private listen;
+	private dispatchPacket;
+	addTask(task: () => Promise<void> | void): void;
+	removeTask(task: () => Promise<void> | void): void;
+	private dispatchTasks;
+	private setStatus;
 }
 export {};
-//# sourceMappingURL=network.d.ts.map

package/dist/dts/network/packet/index.d.ts

@@ -1,3 +1,2 @@
-export { PacketType } from './packet.js';
-export type { PacketData } from './packet.js';
-//# sourceMappingURL=index.d.ts.map
+export { DisconnectPacket, DisconnectType } from "./packet-types.js";
+export { PacketType, type Packet, type PacketData } from "./packet.js";

package/dist/dts/network/packet/packet-types.d.ts

@@ -1,63 +1,84 @@
-import type { AppJson } from '../../app.js';
-import { App } from '../../app.js';
-import type { Model } from '../../model.js';
-import { PacketType } from './packet.js';
+import type { AppJson } from "../../app.js";
+import { App } from "../../app.js";
+import { PacketType } from "./packet.js";
 type ProtocolInfo = {
-    version: string;
+	version: string;
+};
+type RSANumbers = {
+	e: string;
+	n: string;
+};
+type EncryptionRequest = {
+	kind: "v1";
+	rsa: RSANumbers;
+};
+type EncryptionResponse = {
+	kind: "v1";
+	rsa: RSANumbers;
+	aes: string;
+};
+export type ServerMeta = {
+	protocol: ProtocolInfo;
+	encryption: EncryptionRequest | null;
+	hash: string | undefined;
 };
 type ConnectPacketJson = {
-    app: AppJson;
-    protocol: ProtocolInfo;
-    token?: string;
-    is_dashboard?: boolean;
-};
-export declare class ConnectPacket implements Model<ConnectPacketJson> {
-    readonly app: App;
-    readonly protocol: ProtocolInfo;
-    readonly token?: string;
-    readonly isDashboard?: boolean;
-    constructor(options: {
-        app: App;
-        protocol: ProtocolInfo;
-        token?: string;
-        is_dashboard?: boolean;
-    });
-    static fromJson(data: ConnectPacketJson): ConnectPacket;
-    toJson(): ConnectPacketJson;
+	protocol: ProtocolInfo;
+	app: AppJson;
+	token: string;
+	encryption: EncryptionResponse | null;
+};
+export declare class ConnectPacket {
+	readonly protocol: ProtocolInfo;
+	readonly app: App;
+	readonly token: string;
+	readonly encryption: EncryptionResponse | null;
+	constructor(options: {
+		protocol: ProtocolInfo;
+		app: App;
+		token: string;
+		encryption?: EncryptionResponse | null;
+	});
+	static deserialize(data: ConnectPacketJson): ConnectPacket;
+	static serialize(data: ConnectPacket): ConnectPacketJson;
 }
 export declare enum DisconnectType {
-    INVALID_TOKEN = "invalid_token",
-    INVALID_ORIGIN = "invalid_origin",
-    INVALID_VERSION = "invalid_version",
-    INVALID_PACKET_TYPE = "invalid_packet_type",
-    INVALID_PACKET_DATA = "invalid_packet_data",
-    INVALID_PACKET = "invalid_packet",
-    INTERNAL_ERROR = "internal_error",
-    ANOTHER_CONNECTION = "another_connection",
-    PERMISSION_DENIED = "permission_denied",
-    SERVER_RESTART = "server_restart",
-    SHUTDOWN = "shutdown",
-    CLOSE = "close"
+	INVALID_TOKEN = "invalid_token",
+	INVALID_ORIGIN = "invalid_origin",
+	INVALID_VERSION = "invalid_version",
+	INVALID_PACKET_TYPE = "invalid_packet_type",
+	INVALID_PACKET_DATA = "invalid_packet_data",
+	INVALID_PACKET = "invalid_packet",
+	INTERNAL_ERROR = "internal_error",
+	ANOTHER_CONNECTION = "another_connection",
+	PERMISSION_DENIED = "permission_denied",
+	APP_REMOVED = "app_removed",
+	SERVER_RESTART = "server_restart",
+	SHUTDOWN = "shutdown",
+	CLOSE = "close"
 }
 type DisconnectPacketJson = {
-    type: DisconnectType;
-    message: string | null;
-};
-export declare class DisconnectPacket implements Model<DisconnectPacketJson> {
-    readonly type: DisconnectType;
-    readonly message: string | null;
-    constructor(options: {
-        type: DisconnectType;
-        message?: string | null;
-    });
-    static fromJson(data: DisconnectPacketJson): DisconnectPacket;
-    toJson(): DisconnectPacketJson;
+	type: DisconnectType;
+	message: string | null;
+};
+export declare class DisconnectPacket {
+	readonly type: DisconnectType;
+	readonly message: string | null;
+	constructor(options: {
+		type: DisconnectType;
+		message?: string | null;
+	});
+	static serialize(data: DisconnectPacket): DisconnectPacketJson;
+	static deserialize(data: DisconnectPacketJson): DisconnectPacket;
+	static fromJson(data: DisconnectPacketJson): DisconnectPacket;
+	toJson(): DisconnectPacketJson;
 }
 export declare const PACKET_TYPES: {
-    CONNECT: PacketType<ConnectPacket>;
-    DISCONNECT: PacketType<DisconnectPacket>;
-    TOKEN: PacketType<string>;
-    READY: PacketType<undefined>;
+	SERVER_META: PacketType<ServerMeta>;
+	CONNECT: PacketType<ConnectPacket>;
+	DISCONNECT: PacketType<DisconnectPacket>;
+	TOKEN: PacketType<string>;
+	READY: PacketType<undefined>;
+	ENCRYPTED_PACKET: PacketType<Uint8Array>;
 };
 export {};
-//# sourceMappingURL=packet-types.d.ts.map

package/dist/dts/network/packet/packet.d.ts

@@ -1,24 +1,28 @@
-import type { Identifier } from '../../identifier.js';
-import { type Serializable } from '../../serializer.js';
-export interface PacketData {
-    readonly type: string;
-    readonly data: Uint8Array;
-}
-export interface Packet<T = unknown> {
-    readonly type: PacketType<T>;
-    readonly data: T;
-}
+import type { Identifier } from "../../identifier";
+import { JsonType, type Serializable } from "../../serialize";
+export type PacketData = {
+	readonly type: string;
+	readonly data: Uint8Array;
+};
+export type Packet<T = unknown> = {
+	readonly type: PacketType<T>;
+	readonly data: T;
+};
 export declare class PacketType<T> {
-    readonly id: Identifier;
-    readonly serializer: Serializable<T, Uint8Array>;
-    constructor(id: Identifier, serializer: Serializable<T, Uint8Array>);
-    static createJson<T>(identifier: Identifier, { name, serializer, }: {
-        name: string;
-        serializer?: Serializable<T, any>;
-    }): PacketType<T>;
-    static createSerialized<T>(identifier: Identifier, { name, serializer, }: {
-        name: string;
-        serializer: Serializable<T, Uint8Array>;
-    }): PacketType<T>;
+	readonly id: Identifier;
+	readonly serializer: Serializable<T, Uint8Array>;
+	constructor(id: Identifier, serializer: Serializable<T, Uint8Array>);
+	new(data: T): Packet<T>;
+	match(packet: Packet): packet is Packet<T>;
+	static createJson<
+		T,
+		D extends JsonType = JsonType
+	>(identifier: Identifier, { name, serializer }: {
+		name: string;
+		serializer?: Serializable<T, D>;
+	}): PacketType<T>;
+	static createSerialized<T>(identifier: Identifier, { name, serializer }: {
+		name: string;
+		serializer: Serializable<T, Uint8Array>;
+	}): PacketType<T>;
 }
-//# sourceMappingURL=packet.d.ts.map

package/dist/dts/network/websocket-transport.d.ts

@@ -0,0 +1,24 @@
+import type { Address } from "../address.js";
+import type { Serializable } from "../serialize";
+import type { Connection, Transport } from "./connection.js";
+import type { Packet, PacketData } from "./packet/packet.js";
+export declare class WebsocketTransport implements Transport {
+	private readonly address;
+	constructor(address: Address);
+	private get wsEndpoint();
+	connect(): Promise<Connection>;
+}
+export declare class WebsocketConnection implements Connection {
+	private socket;
+	private readonly packetQueue;
+	private receiveWaiter;
+	private readingPromise;
+	private beingClosed;
+	constructor(socket: WebSocket);
+	static fromSocket(socket: WebSocket): Promise<WebsocketConnection>;
+	private onMessage;
+	receive(serializer: Serializable<Packet<unknown>, PacketData>): Promise<Packet | null>;
+	get closed(): boolean;
+	close(): void;
+	send(packet: Packet, serializer: Serializable<Packet<unknown>, PacketData>): void;
+}

package/dist/dts/omu.d.ts

@@ -1,50 +1,61 @@
-import type { App } from './app.js';
-import type { Client, ClientEvents } from './client.js';
-import type { Unlisten } from './event-emitter.js';
-import { type AssetExtension } from './extension/asset/index.js';
-import { type DashboardExtension } from './extension/dashboard/index.js';
-import { type EndpointExtension } from './extension/endpoint/index.js';
-import { type I18nExtension } from './extension/i18n/index.js';
-import { ExtensionRegistry } from './extension/index.js';
-import { type LoggerExtension } from './extension/logger/logger-extension.js';
-import { type PermissionExtension } from './extension/permission/index.js';
-import { type PluginExtension } from './extension/plugin/index.js';
-import { type RegistryExtension } from './extension/registry/index.js';
-import { type ServerExtension } from './extension/server/index.js';
-import { type SignalExtension } from './extension/signal/index.js';
-import { type TableExtension } from './extension/table/index.js';
-import type { Address, Connection } from './network/index.js';
-import { Network } from './network/index.js';
-import type { PacketType } from './network/packet/packet.js';
-import { type TokenProvider } from './token.js';
-export declare class Omu implements Client {
-    readonly app: App;
-    ready: boolean;
-    running: boolean;
-    readonly event: ClientEvents;
-    readonly token: TokenProvider;
-    readonly address: Address;
-    readonly network: Network;
-    readonly endpoints: EndpointExtension;
-    readonly permissions: PermissionExtension;
-    readonly plugins: PluginExtension;
-    readonly dashboard: DashboardExtension;
-    readonly extensions: ExtensionRegistry;
-    readonly tables: TableExtension;
-    readonly registries: RegistryExtension;
-    readonly signals: SignalExtension;
-    readonly assets: AssetExtension;
-    readonly i18n: I18nExtension;
-    readonly server: ServerExtension;
-    readonly logger: LoggerExtension;
-    constructor(app: App, options?: {
-        address?: Address;
-        token?: TokenProvider;
-        connection?: Connection;
-    });
-    send<T>(packetType: PacketType<T>, data: T): void;
-    start(): Promise<void>;
-    stop(): void;
-    onReady(callback: () => void): Unlisten;
+import { ExtensionRegistry } from "./api";
+import { type AssetExtension } from "./api/asset/extension";
+import { type DashboardExtension } from "./api/dashboard/extension";
+import { type EndpointExtension } from "./api/endpoint/extension";
+import { HttpExtension } from "./api/http/extension";
+import { type I18nExtension } from "./api/i18n/extension";
+import { type LoggerExtension } from "./api/logger/extension.js";
+import { type PermissionExtension } from "./api/permission/extension";
+import { type PluginExtension } from "./api/plugin/extension";
+import { type RegistryExtension } from "./api/registry/extension";
+import { type ServerExtension } from "./api/server/extension";
+import { SessionExtension } from "./api/session";
+import { type SignalExtension } from "./api/signal/extension";
+import { type TableExtension } from "./api/table/extension";
+import type { App } from "./app.js";
+import type { Unlisten } from "./event";
+import { EventEmitter } from "./event";
+import type { Address, Connection } from "./network";
+import { Network } from "./network";
+import { Transport } from "./network/connection.js";
+import type { PacketType } from "./network/packet/packet.js";
+import { type TokenProvider } from "./token.js";
+export type ClientEvents = {
+	started: EventEmitter<[]>;
+	stopped: EventEmitter<[]>;
+	ready: EventEmitter<[]>;
+};
+export declare class Omu {
+	readonly app: App;
+	ready: boolean;
+	running: boolean;
+	readonly event: ClientEvents;
+	readonly token: TokenProvider;
+	readonly address: Address;
+	readonly sessions: SessionExtension;
+	readonly network: Network;
+	readonly endpoints: EndpointExtension;
+	readonly permissions: PermissionExtension;
+	readonly plugins: PluginExtension;
+	readonly dashboard: DashboardExtension;
+	readonly extensions: ExtensionRegistry;
+	readonly tables: TableExtension;
+	readonly registries: RegistryExtension;
+	readonly signals: SignalExtension;
+	readonly assets: AssetExtension;
+	readonly i18n: I18nExtension;
+	readonly server: ServerExtension;
+	readonly logger: LoggerExtension;
+	readonly http: HttpExtension;
+	constructor(app: App, options?: {
+		address?: Address;
+		token?: TokenProvider | string;
+		transport?: Transport;
+		connection?: Connection;
+	});
+	send<T>(packetType: PacketType<T>, data: T): void;
+	start(): Promise<void>;
+	stop(): void;
+	onReady(callback: () => void): Unlisten;
+	waitForReady(): Promise<void>;
 }
-//# sourceMappingURL=omu.d.ts.map

package/dist/dts/serialize/bytebuffer.d.ts

@@ -0,0 +1,71 @@
+import { JsonType } from "./serializer.js";
+export declare class Flags {
+	private value;
+	private length;
+	constructor(options: {
+		value?: number;
+		length?: number;
+	});
+	has(position: number): boolean;
+	get(position: number): boolean;
+	ifSet<T>(position: number, callback: () => T): T | undefined;
+	set(position: number, value: boolean): void;
+	write(writer: ByteWriter): void;
+	static read(reader: ByteReader, length: number): Flags;
+}
+export declare class ByteWriter {
+	private dataView;
+	private buffer;
+	private offset;
+	private finished;
+	constructor(init?: ArrayBuffer, offset?: number);
+	static fromUint8Array(buffer: Uint8Array): ByteWriter;
+	private allocate;
+	write(data: Uint8Array): ByteWriter;
+	writeBoolean(value: boolean): ByteWriter;
+	writeInt8(value: number): ByteWriter;
+	writeUint8(value: number): ByteWriter;
+	writeInt16(value: number): ByteWriter;
+	writeUint16(value: number): ByteWriter;
+	writeInt32(value: number): ByteWriter;
+	writeUint32(value: number): ByteWriter;
+	writeInt64(value: bigint): ByteWriter;
+	writeUint64(value: bigint): ByteWriter;
+	writeULEB128(value: number): ByteWriter;
+	writeFloat16(value: number): ByteWriter;
+	writeFloat32(value: number): ByteWriter;
+	writeFloat64(value: number): ByteWriter;
+	writeUint8Array(value: Uint8Array): ByteWriter;
+	writeString(value: string): ByteWriter;
+	writeJSON(value: JsonType): ByteWriter;
+	writeFlags(flags: Flags): ByteWriter;
+	finish(): Uint8Array;
+}
+export declare class ByteReader {
+	private dataView;
+	private offset;
+	private finished;
+	private constructor();
+	static fromUint8Array(buffer: Uint8Array): ByteReader;
+	static fromArrayBuffer(buffer: ArrayBuffer): ByteReader;
+	static fromBlob(blob: Blob): Promise<ByteReader>;
+	read(size: number): Uint8Array;
+	readBoolean(): boolean;
+	readInt8(): number;
+	readUint8(): number;
+	readInt16(): number;
+	readUint16(): number;
+	readInt32(): number;
+	readUint32(): number;
+	readInt64(): bigint;
+	readUint64(): bigint;
+	readULEB128(): number;
+	readFloat16(): number;
+	readFloat32(): number;
+	readFloat64(): number;
+	readUint8Array(): Uint8Array;
+	readString(): string;
+	readJSON<T extends JsonType>(): T;
+	readFlags(length: number): Flags;
+	finish(): void;
+}

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

@@ -0,0 +1,2 @@
+export { ByteReader, ByteWriter, Flags } from "./bytebuffer";
+export { JsonType, Serializer, type Serializable } from "./serializer";