@omujs/omu 0.9.10 → 0.9.26

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

@@ -0,0 +1,174 @@
+import { Identifier } from "../../identifier";
+import { Omu } from "../../omu";
+import { JsonType } from "../../serialize";
+import { Extension, ExtensionType } from "../extension";
+export declare const HTTP_EXTENSION_TYPE: ExtensionType<HttpExtension>;
+export declare const HTTP_REQUEST_PERMISSION_ID: Identifier;
+type RequestHandle = {
+	id: string;
+};
+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>;
+}
+type HttpResponse = RequestHandle & {
+	header: Record<string, string>;
+	status: number;
+	statusText: string;
+	url: string;
+	history: HttpResponse[];
+	redirected: boolean;
+};
+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;
+};
+type WebSocketOpen = RequestHandle & {
+	url: string;
+	protocol?: string | null;
+};
+type WebSocketClose = RequestHandle & {
+	code?: number;
+	reason?: string | null;
+};
+type WebSocketHandle = {
+	ws: OmuWS;
+	open: (response: WebSocketOpen) => void;
+	dispatch: (data: DataChunk<WSDataMeta>) => void;
+	close: (response: WebSocketClose) => void;
+	error: (response: WebSocketError) => void;
+};
+type WSDataMeta = {
+	id: string;
+	type: typeof WSMsgType.TEXT | typeof WSMsgType.BINARY | typeof WSMsgType.PING | typeof WSMsgType.PONG;
+};
+type WebSocketError = RequestHandle & {
+	type: "ConnectionRefused";
+	reason?: string | null;
+};
+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>;
+}
+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>;
+}
+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 declare class OmuWS {
+	protected readonly omu: Omu;
+	protected readonly id: Identifier;
+	protected readonly addQueue: (data: WSData) => void;
+	protected readonly dispose: () => void;
+	protected readonly receiveQueue: WSMsg[];
+	private receiveResolve;
+	private status;
+	constructor(omu: Omu, id: Identifier, addQueue: (data: WSData) => void, dispose: () => void, receiveQueue?: WSMsg[], receiveResolve?: (() => void) | undefined, status?: "connecting" | "open" | "closed");
+	static create(omu: Omu, id: Identifier, addQueue: (data: WSData) => void, dispose: () => void): 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) => any) | null;
+	onerror: ((this: WebSocket, ev: Event) => any) | null;
+	onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
+	onopen: ((this: WebSocket, ev: Event) => any) | 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]) => any): void;
+	removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any): void;
+}
+export {};

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

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

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

@@ -0,0 +1,22 @@
+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[]>;
+	private locales?;
+	defaultLocales?: Locale[];
+	constructor(omu: Omu);
+	getLocales(): readonly Locale[];
+	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

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

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

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

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,18 @@
+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;
+}

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

@@ -0,0 +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/dist/dts/api/plugin/index.d.ts

@@ -0,0 +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/dist/dts/api/plugin/package-info.d.ts

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

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

@@ -0,0 +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/dist/dts/api/registry/registry.d.ts

@@ -0,0 +1,44 @@
+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<T> | T): Promise<T>;
+	listen(fn: (value: T) => void): Unlisten;
+}

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

@@ -0,0 +1,47 @@
+import { App, AppJson } from "../../app.js";
+import { Identifier, IdentifierMap } from "../../identifier";
+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;
+	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 interface AppIndexRegistryJSON {
+	id: string;
+	apps: Record<string, AppJson>;
+}
+export declare class AppIndexRegistry {
+	id: Identifier;
+	apps: IdentifierMap<App>;
+	constructor(id: Identifier, apps: IdentifierMap<App>);
+	static fromJSON(json: AppIndexRegistryJSON): AppIndexRegistry;
+}

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,51 @@
+import { App } from "../../app";
+import { Identifier, IntoId } from "../../identifier";
+import { Omu } from "../../omu";
+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, { onConnect, onDisconnect }: {
+		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<GenerateTokenResponse>;
+}

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,22 @@
+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/index.d.ts

@@ -0,0 +1 @@
+export { SignalPermissions, SignalType, type Signal } from "./signal.js";