@omujs/omu 0.9.48 → 0.9.49

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

@@ -0,0 +1,25 @@
+import { Identifier, IntoId } from '../../identifier';
+import { Omu } from '../../omu';
+import { ExtensionType } from '../extension.js';
+export declare const ASSET_EXTENSION_TYPE: ExtensionType<AssetExtension>;
+export type Asset = {
+    id: Identifier;
+    buffer: Uint8Array;
+};
+export declare const ASSET_PERMISSION_ID: Identifier;
+export declare class AssetExtension {
+    private readonly omu;
+    readonly type: ExtensionType<AssetExtension>;
+    private assetToken;
+    constructor(omu: Omu);
+    upload(identifier: IntoId, buffer: Uint8Array): Promise<Identifier>;
+    uploadMany(...files: Asset[]): Promise<Identifier[]>;
+    download(identifier: IntoId): Promise<Asset>;
+    downloadMany(...identifiers: IntoId[]): Promise<Asset[]>;
+    delete(identifier: IntoId): Promise<void>;
+    private requestGenerateAssetToken;
+    url(id: IntoId, options?: {
+        cache?: 'no-cache';
+    }): string;
+    proxy(url: string): string;
+}

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

@@ -0,0 +1,2 @@
+export { ASSET_PERMISSION_ID, } from './extension';
+export type { Asset } from './extension';

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

@@ -0,0 +1,183 @@
+import { App, AppJson } from '../../app.js';
+import { Identifier } from '../../identifier';
+import { Omu } from '../../omu.js';
+import { PromiseResult } from '../../result.js';
+import { ExtensionType } from '../extension.js';
+import { PermissionTypeJson } from '../permission/permission.js';
+import { PackageInfo } from '../plugin/package-info.js';
+import { Registry } from '../registry/registry.js';
+import { AppIndexRegistryMeta } from '../server/extension.js';
+import type { Table } from '../table/table.js';
+import type { DashboardHandler } from './handler.js';
+import { AppInstallResponse, DragDrop, DragDropReadResponse, DragEnter, DragLeave, DragOver, FileDragPacket } from './packets.js';
+export declare const DASHBOARD_EXTENSION_TYPE: ExtensionType<DashboardExtension>;
+export declare const DASHBOARD_SET_PERMISSION_ID: Identifier;
+export declare const DASHBOARD_OPEN_APP_PERMISSION_ID: Identifier;
+export declare const DASHOBARD_APP_READ_PERMISSION_ID: Identifier;
+export declare const DASHOBARD_APP_EDIT_PERMISSION_ID: Identifier;
+export declare const DASHBOARD_APP_INSTALL_PERMISSION_ID: Identifier;
+export declare const DAShBOARD_DRAG_DROP_PERMISSION_ID: Identifier;
+type DragDropHandler = {
+    onEnter(fn: (event: DragEnter) => unknown): void;
+    onOver(fn: (event: DragOver) => unknown): void;
+    onDrop(fn: (event: DragDrop) => unknown): void;
+    onLeave(fn: (event: DragLeave) => unknown): void;
+    read(id: string): Promise<DragDropReadResponse>;
+};
+export type Cookie = {
+    name: string;
+    value: string;
+};
+export type WebviewRequest = {
+    url: string;
+    script?: string;
+};
+export type WebviewPacket = {
+    id: string;
+};
+export type UserResponse<T = undefined> = {
+    type: 'ok';
+    value: T;
+} | {
+    type: 'blocked';
+} | {
+    type: 'cancelled';
+};
+export type UserError = Exclude<UserResponse, {
+    type: 'ok';
+}>;
+export type WebviewResponse = UserResponse<WebviewPacket>;
+export declare const DASHBOARD_WEBVIEW_PERMISSION_ID: Identifier;
+export type HostRequest = {
+    host: string;
+};
+export type GetCookiesRequest = {
+    url: string;
+};
+export type WebviewEvent = {
+    type: 'closed';
+} | {
+    type: 'resize';
+    dimentions: {
+        x: number;
+        y: number;
+    };
+} | {
+    type: 'cookie';
+    cookies: Cookie[];
+};
+export type WebviewEventListeners = {
+    [K in WebviewEvent['type']]?: Array<(event: Extract<WebviewEvent, {
+        type: K;
+    }>) => void>;
+};
+export type WebviewEventPacket = {
+    id: Identifier;
+    target: Identifier;
+    event: WebviewEvent;
+};
+export type WebviewHandle = {
+    readonly id: Identifier;
+    readonly url: string;
+    getCookies(): PromiseResult<Cookie[], UserError>;
+    on<T extends WebviewEvent['type']>(key: T, callback: (event: Extract<WebviewEvent, {
+        type: T;
+    }>) => void): void;
+    close(): Promise<void>;
+    join(): Promise<void>;
+};
+export type WebviewEventEmit = <T extends WebviewEvent['type']>(event: Extract<WebviewEvent, {
+    type: T;
+}>) => void;
+type AllowedHost = {
+    id: string;
+    hosts: string[];
+};
+export declare const DASHBOARD_SPEECH_RECOGNITION_PERMISSION_ID: Identifier;
+export type TranscriptSegment = {
+    confidence: number;
+    transcript: string;
+};
+export type TranscriptStatus = {
+    type: 'idle';
+} | {
+    type: 'result';
+    timestamp: number;
+    segments: TranscriptSegment[];
+} | {
+    type: 'final';
+    timestamp: number;
+    segments: TranscriptSegment[];
+} | {
+    type: 'audio_started';
+    timestamp: number;
+} | {
+    type: 'audio_ended';
+    timestamp: number;
+};
+export type SpeechRecognitionStart = {
+    type: 'start';
+};
+interface PromptRequestBase<T extends string> {
+    kind: T;
+    id: string;
+}
+export interface PromptRequestAppPermissions extends PromptRequestBase<'app/permissions'> {
+    app: AppJson;
+    permissions: PermissionTypeJson[];
+}
+export interface PromptRequestAppPlugins extends PromptRequestBase<'app/plugins'> {
+    app: AppJson;
+    packages: PackageInfo[];
+}
+export interface PromptRequestAppInstall extends PromptRequestBase<'app/install'> {
+    app: AppJson;
+    dependencies: Record<string, AppJson>;
+}
+export interface PromptRequestAppUpdate extends PromptRequestBase<'app/update'> {
+    old_app: AppJson;
+    new_app: AppJson;
+    dependencies: Record<string, AppJson>;
+}
+export interface PromptRequestIndexInstall extends PromptRequestBase<'index/install'> {
+    index_url: string;
+    meta?: AppIndexRegistryMeta;
+}
+export interface PortProcess {
+    port: number;
+    name: string;
+    exe: string;
+}
+export interface PromptRequestHttpPort extends PromptRequestBase<'http/port'> {
+    app: AppJson;
+    processes: PortProcess[];
+}
+export type PromptRequest = (PromptRequestAppPermissions | PromptRequestAppPlugins | PromptRequestAppInstall | PromptRequestAppUpdate | PromptRequestIndexInstall | PromptRequestHttpPort);
+export type PromptResult = 'accept' | 'deny' | 'block';
+export declare class DashboardExtension {
+    private readonly omu;
+    readonly type: ExtensionType<DashboardExtension>;
+    private dashboard;
+    private dragDropHandler;
+    private dragDropListeners;
+    readonly allowedHosts: Table<AllowedHost>;
+    readonly speechRecognition: Registry<TranscriptStatus>;
+    private readonly webviewHandles;
+    constructor(omu: Omu);
+    private executeRequestForDashboard;
+    private handlePromptRequest;
+    private handleOpenApp;
+    private handleDragDropRequest;
+    private handleDragDropReadRequest;
+    private getDashboard;
+    set(dashboard: DashboardHandler): void;
+    requestWebview(options: WebviewRequest): PromiseResult<WebviewHandle, UserError>;
+    getCookies(options: GetCookiesRequest): PromiseResult<Cookie[], UserError>;
+    openApp(app: App): Promise<void>;
+    installApp(app: App): Promise<AppInstallResponse>;
+    clearBlockedPrompts(): Promise<null>;
+    requestDragDrop(): Promise<DragDropHandler>;
+    notifyDropDragState(packet: FileDragPacket): Promise<void>;
+    requestSpeechRecognition(): PromiseResult<Registry<TranscriptStatus>, UserError>;
+}
+export {};

package/{src/api/dashboard/handler.ts → dist/dts/api/dashboard/handler.d.ts}

@@ -2,9 +2,7 @@ import type { App } from '../../app.js';
 import { Identifier } from '../../identifier';
 import { InvokedParams } from '../endpoint/packets.js';
 import { Cookie, GetCookiesRequest, HostRequest, PromptRequestAppInstall, PromptRequestAppPermissions, PromptRequestAppPlugins, PromptRequestAppUpdate, PromptRequestHttpPort, PromptRequestIndexInstall, PromptResult, SpeechRecognitionStart, UserResponse, WebviewEvent, WebviewPacket, WebviewRequest } from './extension.js';
-
 import type { DragDropReadRequestDashboard, DragDropReadResponse, DragDropRequestDashboard } from './packets.js';
-
 export interface DashboardHandler {
     handlePermissionRequest(request: PromptRequestAppPermissions): Promise<PromptResult>;
     handlePluginRequest(request: PromptRequestAppPlugins): Promise<PromptResult>;

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

@@ -0,0 +1,3 @@
+export { Cookie, DASHBOARD_APP_INSTALL_PERMISSION_ID, DAShBOARD_DRAG_DROP_PERMISSION_ID, DASHBOARD_OPEN_APP_PERMISSION_ID, DASHBOARD_SET_PERMISSION_ID, DASHBOARD_SPEECH_RECOGNITION_PERMISSION_ID, DASHBOARD_WEBVIEW_PERMISSION_ID, DASHOBARD_APP_EDIT_PERMISSION_ID, DASHOBARD_APP_READ_PERMISSION_ID, GetCookiesRequest, HostRequest, UserResponse, WebviewPacket, WebviewRequest, type PortProcess, type PromptRequest, type PromptRequestAppInstall, type PromptRequestAppPermissions, type PromptRequestAppPlugins, type PromptRequestAppUpdate, type PromptRequestHttpPort, type PromptRequestIndexInstall, type PromptResult, type SpeechRecognitionStart, type TranscriptSegment, type TranscriptStatus, type WebviewEvent, } from './extension.js';
+export type { DashboardHandler } from './handler';
+export { DragDropFile, DragDropReadRequestDashboard, DragDropReadResponse, DragDropRequestDashboard, FileData, } from './packets.js';

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

@@ -0,0 +1,73 @@
+import { App, AppJson } from '../../app.js';
+export type AppInstallResponse = {
+    accepted: boolean;
+};
+export type DragDropFile = {
+    type: 'file' | 'directory';
+    size: number;
+    name: string;
+};
+export type DragDropPosition = {
+    x: number;
+    y: number;
+};
+export type DragEnter = {
+    type: 'enter';
+    drag_id: string;
+    files: DragDropFile[];
+    position: DragDropPosition;
+};
+export type DragOver = {
+    type: 'over';
+    drag_id: string;
+    position: DragDropPosition;
+};
+export type DragDrop = {
+    type: 'drop';
+    drag_id: string;
+    position: DragDropPosition;
+    files: DragDropFile[];
+};
+export type DragLeave = {
+    type: 'leave';
+    drag_id: string;
+};
+export type DragState = DragEnter | DragOver | DragDrop | DragLeave;
+export type FileDragPacket = {
+    drag_id: string;
+    app: App;
+    state: DragState;
+};
+export type DragDropReadRequest = {
+    drag_id: string;
+};
+export type DragDropReadRequestDashboard = {
+    request_id: string;
+    drag_id: string;
+};
+export type DragDropReadMeta = {
+    request_id: string;
+    drag_id: string;
+    files: readonly DragDropFile[];
+};
+export type FileData = {
+    file: DragDropFile;
+    buffer: Uint8Array;
+};
+export declare class DragDropReadResponse {
+    readonly meta: DragDropReadMeta;
+    readonly files: Record<string, FileData>;
+    readonly version: number;
+    constructor(meta: DragDropReadMeta, files: Record<string, FileData>, version?: number);
+    static serialize(data: DragDropReadResponse): Uint8Array;
+    static deserialize(data: Uint8Array): DragDropReadResponse;
+}
+export type DragDropRequest = object;
+export type DragDropRequestDashboard = {
+    request_id: string;
+    app: AppJson;
+};
+export type DragDropRequestResponse = {
+    request_id: string;
+    ok: boolean;
+};

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

@@ -0,0 +1,21 @@
+import { Identifier, IntoId } from '../../identifier';
+import { JsonType, type Serializable } from '../../serialize';
+export declare class EndpointType<Req = unknown, Res = unknown> {
+    readonly id: Identifier;
+    readonly requestSerializer: Serializable<Req, Uint8Array>;
+    readonly responseSerializer: Serializable<Res, Uint8Array>;
+    readonly permissionId?: Identifier | undefined;
+    constructor(id: Identifier, requestSerializer: Serializable<Req, Uint8Array>, responseSerializer: Serializable<Res, Uint8Array>, permissionId?: Identifier | undefined);
+    static createJson<Req, Res, ReqData extends JsonType = JsonType, ResData extends JsonType = JsonType>(identifier: IntoId, { name, requestSerializer, responseSerializer, permissionId, }: {
+        name: string;
+        requestSerializer?: Serializable<Req, ReqData>;
+        responseSerializer?: Serializable<Res, ResData>;
+        permissionId?: IntoId;
+    }): EndpointType<Req, Res>;
+    static createSerialized<Req, Res>(identifier: IntoId, { name, requestSerializer, responseSerializer, permissionId, }: {
+        name: string;
+        requestSerializer: Serializable<Req, Uint8Array>;
+        responseSerializer: Serializable<Res, Uint8Array>;
+        permissionId?: IntoId;
+    }): EndpointType<Req, Res>;
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,125 @@
+import { DataChunk, RequestHandle } from './http';
+export type WSData = string | ArrayBufferLike | Blob | ArrayBufferView;
+export declare const WSMsgType: {
+    readonly CONTINUATION: 0;
+    readonly TEXT: 1;
+    readonly BINARY: 2;
+    readonly PING: 9;
+    readonly PONG: 10;
+    readonly CLOSE: 8;
+};
+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

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

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

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

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