@omujs/omu 0.9.47 → 0.9.49

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

@@ -0,0 +1,25 @@
+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

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

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,19 @@
+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/{src/api/permission/index.ts → dist/dts/api/permission/index.d.ts}

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

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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,43 @@
+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/{src/api/plugin/index.ts → dist/dts/api/plugin/index.d.ts}

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

package/{src/api/plugin/package-info.ts → dist/dts/api/plugin/package-info.d.ts}

@@ -1,10 +1,8 @@
-// type generated from https://warehouse.pypa.io/api-reference/json.html
 export type Downloads = {
     last_day: number;
     last_month: number;
     last_week: number;
 };
-
 export type ProjectUrls = {
     'Bug Reports': string;
     'Funding': string;
@@ -45,7 +43,6 @@ export type Digests = {
     md5: string;
     sha256: string;
 };
-
 export type ReleasesItem = {
     comment_text: string;
     digests: Digests;
@@ -63,12 +60,10 @@ export type ReleasesItem = {
     yanked: boolean;
     yanked_reason: string | null;
 };
-
 export type Releases = {
     [key: string]: ReleasesItem[];
 };
 export type Urls = ReleasesItem[];
-
 export type VulnerabilitiesItem = {
     aliases: string[];
     details: string;
@@ -79,9 +74,7 @@ export type VulnerabilitiesItem = {
     source: string;
     withdrawn: string | null;
 };
-
 export type Vulnerabilities = VulnerabilitiesItem[];
-
 export type PackageInfo = {
     info: Info;
     last_serial: number;

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

@@ -0,0 +1,23 @@
+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/{src/api/registry/index.ts → dist/dts/api/registry/index.d.ts}

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

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

@@ -0,0 +1,20 @@
+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/{src/api/registry/registry.ts → dist/dts/api/registry/registry.d.ts}

@@ -1,67 +1,35 @@
 import type { Unlisten } from '../../event';
 import { Identifier, IntoId } from '../../identifier';
 import type { JsonType, Serializable } from '../../serialize';
-import { Serializer } from '../../serialize';
-
 export interface RegistryPermissionsJSON {
     all?: string;
     read?: string;
     write?: string;
 }
-
 export interface RegistryPermissions {
     all?: IntoId;
     read?: IntoId;
     write?: IntoId;
 }
-
-export class RegistryType<T> {
-    constructor(
-        public readonly id: Identifier,
-        public readonly defaultValue: T,
-        public readonly serializer: Serializable<T, Uint8Array>,
-        public readonly permissions: RegistryPermissions,
-    ) { }
-
-    public static createJson<T, D extends JsonType = JsonType>(identifier: IntoId, {
-        name,
-        defaultValue,
-        permissions,
-        serializer,
-    }: {
+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> {
-        return new RegistryType(
-            Identifier.from(identifier).join(name),
-            defaultValue,
-            Serializer.pipe<T, D, Uint8Array>(serializer ?? Serializer.noop(), Serializer.json()),
-            permissions ?? {},
-        );
-    }
-
-    public static createSerialized<T>(identifier: IntoId, {
-        name,
-        defaultValue,
-        serializer,
-        permissions,
-    }: {
+    }): RegistryType<T>;
+    static createSerialized<T>(identifier: IntoId, { name, defaultValue, serializer, permissions, }: {
         name: string;
         defaultValue: T;
         serializer: Serializable<T, Uint8Array>;
         permissions?: RegistryPermissions;
-    }): RegistryType<T> {
-        return new RegistryType(
-            Identifier.from(identifier).join(name),
-            defaultValue,
-            serializer,
-            permissions ?? {},
-        );
-    }
+    }): RegistryType<T>;
 }
-
 export interface Registry<T> {
     readonly type: RegistryType<T>;
     readonly value: T;
@@ -70,25 +38,15 @@ export interface Registry<T> {
     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 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;

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

@@ -0,0 +1,61 @@
+import { App, AppJson } from '../../app.js';
+import { Identifier, IdentifierMap, IntoId } from '../../identifier';
+import { LocalizedText } from '../../localization/localization.js';
+import { Omu } from '../../omu.js';
+import { ExtensionType, type Extension } from '../extension.js';
+import { Registry, RegistryType } from '../registry';
+import { type Table } from '../table';
+export declare const SERVER_EXTENSION_TYPE: ExtensionType<ServerExtension>;
+export interface AppIndexEntry {
+    url: string;
+    meta?: AppIndexRegistryMeta;
+    added_at: string;
+}
+export interface AppIndex {
+    indexes: Record<string, AppIndexEntry>;
+}
+export declare const SERVER_APPS_READ_PERMISSION_ID: Identifier;
+export declare const SERVER_APPS_WRITE_PERMISSION_ID: Identifier;
+export declare const SERVER_INDEX_READ_PERMISSION_ID: Identifier;
+export declare const SERVER_INDEX_REGISTRY_TYPE: RegistryType<AppIndex>;
+export declare const SERVER_SHUTDOWN_PERMISSION_ID: Identifier;
+export declare const TRUSTED_ORIGINS_GET_PERMISSION_ID: Identifier;
+export declare const TRUSTED_ORIGINS_SET_PERMISSION_ID: Identifier;
+export declare class ServerExtension implements Extension {
+    private readonly omu;
+    readonly type: ExtensionType<ServerExtension>;
+    readonly apps: Table<App>;
+    readonly index: Registry<AppIndex>;
+    readonly trustedHosts: Registry<Record<string, string>>;
+    constructor(omu: Omu);
+    shutdown(restart?: boolean): Promise<boolean>;
+}
+export declare class SessionObserver {
+    readonly onConnectCallbacks: Array<(app: App) => Promise<void> | void>;
+    readonly onDisconnectCallbacks: Array<(app: App) => Promise<void> | void>;
+    constructor(onConnectCallbacks: Array<(app: App) => Promise<void> | void>, onDisconnectCallbacks: Array<(app: App) => Promise<void> | void>);
+    onConnect(callback: (app: App) => Promise<void> | void): void;
+    onDisconnect(callback: (app: App) => Promise<void> | void): void;
+}
+export type AppIndexRegistryMeta = {
+    name: LocalizedText;
+    note: LocalizedText;
+};
+export interface AppIndexRegistryJSON {
+    id: string;
+    meta?: AppIndexRegistryMeta;
+    apps: Record<string, AppJson>;
+}
+export declare class AppIndexRegistry {
+    id: Identifier;
+    apps: IdentifierMap<App>;
+    meta: AppIndexRegistryMeta | undefined;
+    constructor(id: Identifier, apps: IdentifierMap<App>, meta: AppIndexRegistryMeta | undefined);
+    static build(options: {
+        id: IntoId;
+        meta: AppIndexRegistryMeta;
+        apps: App[];
+    }): AppIndexRegistry;
+    static fromJSON(json: AppIndexRegistryJSON): AppIndexRegistry;
+    toJSON(): AppIndexRegistryJSON;
+}

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

@@ -0,0 +1 @@
+export { AppIndexRegistry, SERVER_APPS_READ_PERMISSION_ID, SERVER_SHUTDOWN_PERMISSION_ID, TRUSTED_ORIGINS_GET_PERMISSION_ID, TRUSTED_ORIGINS_SET_PERMISSION_ID, type AppIndex, type AppIndexEntry, type AppIndexRegistryJSON, } from './extension.js';

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

@@ -0,0 +1,52 @@
+import { App } from '../../app';
+import { Identifier, IntoId } from '../../identifier';
+import { Omu } from '../../omu';
+import { SessionParam } from '../../token';
+import { Extension, ExtensionType } from '../extension';
+import { SessionObserver } from '../server/extension';
+import { Table } from '../table';
+export declare const SESSION_EXTENSION_TYPE: ExtensionType<SessionExtension>;
+export declare const SESSIONS_READ_PERMISSION_ID: Identifier;
+export type RequestRemoteAppResponse = {
+    type: 'success';
+    token: string;
+    lan_ip: string;
+} | {
+    type: 'error';
+    message: string;
+};
+export declare const REMOTE_APP_REQUEST_PERMISSION_ID: Identifier;
+export type GenerateTokenResponse = {
+    type: 'success';
+    token: string;
+} | {
+    type: 'error';
+    message: string;
+};
+export declare const GENERATE_TOKEN_PERMISSION_ID: Identifier;
+export declare class SessionExtension implements Extension {
+    private readonly omu;
+    readonly type: ExtensionType<SessionExtension>;
+    readonly sessions: Table<App>;
+    private readonly sessionObservers;
+    private readonly requiredApps;
+    constructor(omu: Omu);
+    has(id: IntoId): Promise<boolean>;
+    observe(appId: IntoId, options?: {
+        onConnect?(app: App): void;
+        onDisconnect?(app: App): void;
+    }): SessionObserver;
+    private handleSessionConnect;
+    private handleSessionDisconnect;
+    require(...appIds: IntoId[]): void;
+    private onTask;
+    private onReady;
+    requestRemoteApp(options: {
+        app: App;
+        permissions: IntoId[];
+    }): Promise<RequestRemoteAppResponse>;
+    generateToken(options: {
+        app: App;
+        permissions?: IntoId[];
+    }): Promise<SessionParam>;
+}

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

@@ -0,0 +1 @@
+export { GENERATE_TOKEN_PERMISSION_ID, REMOTE_APP_REQUEST_PERMISSION_ID, SESSION_EXTENSION_TYPE, SessionExtension, SESSIONS_READ_PERMISSION_ID, type RequestRemoteAppResponse, } from './extension';

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

@@ -0,0 +1,19 @@
+import { Omu } from '../../omu';
+import { JsonType, Serializable } from '../../serialize';
+import { ExtensionType, type Extension } from '../extension.js';
+import { SignalType, type Signal } from './signal.js';
+export declare const SIGNAL_EXTENSION_TYPE: ExtensionType<SignalExtension>;
+export declare class SignalExtension implements Extension {
+    private readonly omu;
+    readonly type: ExtensionType<SignalExtension>;
+    private readonly signals;
+    constructor(omu: Omu);
+    private createSignal;
+    json<T, D extends JsonType = JsonType>(name: string, options?: {
+        serializer?: Serializable<T, D>;
+    }): Signal<T>;
+    serialized<T>(name: string, options: {
+        serializer: Serializable<T, Uint8Array>;
+    }): Signal<T>;
+    get<T>(signalType: SignalType<T>): Signal<T>;
+}

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

@@ -0,0 +1,21 @@
+import { Identifier } from '../../identifier';
+import { SignalPermissions, SignalPermissionsJSON } from './signal.js';
+export declare class SignalPacket {
+    readonly id: Identifier;
+    readonly body: Uint8Array;
+    constructor(id: Identifier, body: Uint8Array);
+    static serialize(packet: SignalPacket): Uint8Array;
+    static deserialize(data: Uint8Array): SignalPacket;
+}
+interface SignalRegisterPacketJSON {
+    id: string;
+    permissions: SignalPermissionsJSON;
+}
+export declare class SignalRegisterPacket {
+    readonly id: Identifier;
+    readonly permissions: SignalPermissions;
+    constructor(id: Identifier, permissions: SignalPermissions);
+    static serialize(packet: SignalRegisterPacket): SignalRegisterPacketJSON;
+    static deserialize(data: SignalRegisterPacketJSON): SignalRegisterPacket;
+}
+export {};

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

@@ -0,0 +1,33 @@
+import type { Unlisten } from '../../event';
+import { Identifier, IntoId } from '../../identifier';
+import type { Serializable } from '../../serialize';
+export interface SignalPermissionsJSON {
+    all?: string;
+    listen?: string;
+    send?: string;
+}
+export interface SignalPermissions {
+    all?: IntoId | undefined;
+    listen?: IntoId | undefined;
+    send?: IntoId | undefined;
+}
+export declare class SignalType<T> {
+    readonly id: Identifier;
+    readonly serializer: Serializable<T, Uint8Array>;
+    readonly permissions: SignalPermissions;
+    constructor(id: Identifier, serializer: Serializable<T, Uint8Array>, permissions: SignalPermissions);
+    static createJson<T>(identifier: IntoId, { name, serializer, permissions, }: {
+        name: string;
+        serializer?: Serializable<T, any>;
+        permissions?: SignalPermissions;
+    }): SignalType<T>;
+    static createSerialized<T>(identifier: IntoId, { name, serializer, permissions, }: {
+        name: string;
+        serializer: Serializable<T, Uint8Array>;
+        permissions?: SignalPermissions;
+    }): SignalType<T>;
+}
+export interface Signal<T> {
+    listen(handler: (value: T) => void): Unlisten;
+    notify(body: T): void;
+}

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

@@ -0,0 +1,26 @@
+import { Identifier } from '../../identifier';
+import { Omu } from '../../omu';
+import type { JsonType, Serializable } from '../../serialize';
+import type { Extension } from '../extension.js';
+import { ExtensionType } from '../extension.js';
+import type { Table } from './table.js';
+import { TableType } from './table.js';
+export declare const TABLE_EXTENSION_TYPE: ExtensionType<TableExtension>;
+export declare const TABLE_PERMISSION_ID: Identifier;
+export declare class TableExtension implements Extension {
+    private readonly omu;
+    readonly type: ExtensionType<TableExtension>;
+    private readonly tableMap;
+    constructor(omu: Omu);
+    private createTable;
+    json<T, D extends JsonType = JsonType>(name: string, options: {
+        key: (item: T) => string;
+        serializer?: Serializable<T, D>;
+    }): Table<T>;
+    serialized<T>(name: string, options: {
+        key: (item: T) => string;
+        serializer: Serializable<T, Uint8Array>;
+    }): Table<T>;
+    get<T>(type: TableType<T>): Table<T>;
+    has(identifier: Identifier): boolean;
+}

package/{src/api/table/index.ts → dist/dts/api/table/index.d.ts}

@@ -1,3 +1,2 @@
 export { TABLE_PERMISSION_ID } from './extension.js';
 export { TableType, type Table, type TableConfig } from './table.js';
-

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

@@ -0,0 +1,65 @@
+import { Identifier } from '../../identifier';
+import type { TableConfig } from './table.js';
+export declare class TablePacket {
+    readonly id: Identifier;
+    constructor(id: Identifier);
+    static serialize(packet: TablePacket): Uint8Array;
+    static deserialize(data: Uint8Array): TablePacket;
+}
+export declare class TableItemsPacket {
+    readonly id: Identifier;
+    readonly items: Record<string, Uint8Array>;
+    constructor(id: Identifier, items: Record<string, Uint8Array>);
+    static serialize(packet: TableItemsPacket): Uint8Array;
+    static deserialize(data: Uint8Array): TableItemsPacket;
+}
+export declare class TableKeysPacket {
+    readonly id: Identifier;
+    readonly keys: string[];
+    constructor(id: Identifier, keys: string[]);
+    static serialize(packet: TableKeysPacket): Uint8Array;
+    static deserialize(data: Uint8Array): TableKeysPacket;
+}
+export declare class TableProxyPacket {
+    readonly id: Identifier;
+    readonly items: Record<string, Uint8Array>;
+    readonly key: number;
+    constructor(id: Identifier, items: Record<string, Uint8Array>, key: number);
+    static serialize(packet: TableProxyPacket): Uint8Array;
+    static deserialize(data: Uint8Array): TableProxyPacket;
+}
+export declare class TableFetchPacket {
+    readonly id: Identifier;
+    readonly limit: number;
+    readonly backward: boolean;
+    readonly cursor: string | null;
+    constructor(id: Identifier, limit: number, backward?: boolean, cursor?: string | null);
+    static serialize(packet: TableFetchPacket): Uint8Array;
+    static deserialize(data: Uint8Array): TableFetchPacket;
+}
+export declare class TableFetchRangePacket {
+    readonly id: Identifier;
+    readonly start: string;
+    readonly end: string;
+    constructor(id: Identifier, start: string, end: string);
+    static serialize(packet: TableFetchRangePacket): Uint8Array;
+    static deserialize(data: Uint8Array): TableFetchRangePacket;
+}
+export declare class SetConfigPacket {
+    readonly id: Identifier;
+    readonly config: TableConfig;
+    constructor(id: Identifier, config: TableConfig);
+    static serialize(packet: SetConfigPacket): Uint8Array;
+    static deserialize(data: Uint8Array): SetConfigPacket;
+}
+export declare class SetPermissionPacket {
+    readonly id: Identifier;
+    readonly all: Identifier | null;
+    readonly read: Identifier | null;
+    readonly write: Identifier | null;
+    readonly remove: Identifier | null;
+    readonly proxy: Identifier | null;
+    constructor(id: Identifier, all: Identifier | null, read: Identifier | null, write: Identifier | null, remove: Identifier | null, proxy: Identifier | null);
+    static serialize(packet: SetPermissionPacket): Uint8Array;
+    static deserialize(data: Uint8Array): SetPermissionPacket;
+}