@pixl-app/sdk 0.1.0 → 1.0.0

package/dist/client.d.ts

@@ -1,194 +1,157 @@
-import type { SpotifyNowPlaying, StreamElementsProxyPath } from "./api-types/index.js";
+import { type EventPayloads, type ChannelEvent, type ChannelEventType, type StreamConnected } from "./api-types/index.js";
 import { PixlChat } from "./chat.js";
-import { EventFeed, type FeedOptions } from "./feed.js";
+import { PixlEvents } from "./events.js";
+import { fontFamily, loadFont } from "./fonts.js";
+import { type LiveValue } from "./live-value.js";
+import { PixlSpotify } from "./spotify.js";
+import { PixlStreamElements } from "./streamelements.js";
+import { type ConnectionStatus } from "./stream.js";
 import { PixlTts } from "./tts.js";
-export type PixlStatus = "connecting" | "connected" | "disconnected" | "unauthorized" | "closed";
+import { PixlTwitch } from "./twitch.js";
+import { PixlWidget } from "./widget.js";
+export type { ConnectionStatus };
+/** Ein Event, wie es bei Handlern ankommt */
+export type PixlEvent<T extends ChannelEventType = ChannelEventType> = ChannelEvent<T>;
+/** Kanal, zu dem der Zugang gehört */
+export type Channel = StreamConnected["channel"];
 export type PixlOptions = {
-    /** API-Schlüssel (`pixl_…`), erstellt unter Einstellungen → API-Schlüssel */
-    key: string;
-    /**
-     * Adresse der pixl-Instanz. Standard: der Server, von dem das SDK-Script
-     * geladen wurde, sonst https://pixl.lennox.zip
-     */
+    /** API-Schlüssel (`pixl_…`) aus „API & SDK“. In gehosteten Widgets setzt pixl den Zugang selbst. */
+    key?: string;
+    /** Adresse der pixl-Instanz. Standard: der Server, von dem das Script kam, sonst https://pixl.lennox.zip */
     baseUrl?: string;
-    /** Stream automatisch verbinden (Standard: true). Sonst manuell per connect(). */
+    /** Ohne Server: Vorlagen für Live-Werte, Events per `sendTestEvent()`. Für Vorschauen und Entwicklung. */
+    demo?: boolean;
+    /** Live-Verbindung sofort aufbauen (Standard: true), sonst per `connect()` */
     autoConnect?: boolean;
-    /**
-     * Abbruch und Neuverbinden der Live-Verbindung in der Browser-Konsole melden
-     * (Standard: true). Nur Wechsel, keine Events.
-     */
+    /** Verbindungswechsel in der Konsole melden (Standard: true) */
     logs?: boolean;
+    /** @internal zum Testen */
+    fetch?: typeof fetch;
 };
-export type PixlEvent = {
-    /** Event-Typ, z.B. `twitch.cheer` */
-    event: string;
-    /** Payload laut Event-Referenz */
-    data: Record<string, unknown>;
-    /** true bei erneut abgespielten Events aus dem Eventlog */
-    replay: boolean;
-    /** ID der Eventlog-Zeile (nur bei Events, die im Eventlog stehen) */
-    id?: string;
-    /** Zeitpunkt als ISO-String (nur bei Events, die im Eventlog stehen) */
-    at?: string;
-    /** true, wenn das Event aus der Historie nachgeladen wurde (nur bei feed()) */
-    history?: boolean;
-};
-export type EventHandler = (data: Record<string, unknown>, event: PixlEvent) => void;
-export type StateHandler = (value: unknown, key: string) => void;
-export type EventsQuery = {
-    /** Ab wann: Date, ISO-String, Unix-ms oder `"stream"` (Start des letzten Streams) */
-    since?: Date | string | number;
-    /** Bis wann (exklusiv) */
-    until?: Date | string | number;
-    /** Nur diese Event-Typen */
-    types?: string[];
-    /** Max. Anzahl pro Seite, 1 bis 200 (Standard 50) */
-    limit?: number;
-    /** `nextCursor` der vorherigen Seite */
-    cursor?: string;
-};
-export type EventsPage = {
-    events: {
-        id: string;
-        event: string;
-        data: Record<string, unknown>;
-        at: string;
-    }[];
-    nextCursor: string | null;
+export type RequestOptions = {
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+    /** Statt `body`: Datei oder Daten unverändert als Body (Content-Type aus dem Blob) */
+    raw?: Blob;
+    signal?: AbortSignal;
 };
-export type OrgInfo = {
-    id: string;
-    name: string;
-    logo: string | null;
-    twitchChannelLogin: string | null;
-    /** Erlaubnisse des verwendeten Schlüssels, z.B. `["events:read"]` */
-    scopes: string[];
-};
-export type SubCount = {
-    /** Aktive Subs laut Twitch, inklusive des Streamers selbst (zählt Twitch so) */
-    total: number;
-    /** Sub-Punkte laut Twitch: Stufe 1 = 1, Stufe 2 = 2, Stufe 3 = 6 */
-    points: number;
-    /** Wann pixl die Zahl bei Twitch abgefragt hat (ISO-String) */
-    at: string;
-};
-export declare class PixlApiError extends Error {
-    status: number;
-    /** Maschinenlesbarer Grund, falls der Server einen nennt (z.B. `quota` bei TTS) */
-    problem?: string;
-    constructor(status: number, message: string, problem?: string);
-}
-export declare function toQueryDate(value: Date | string | number): string;
 export declare class Pixl {
-    /** Von global.ts gesetzt: Origin des geladenen SDK-Scripts */
+    /** @internal von global.ts gesetzt: Herkunft des Scripts */
     static defaultBaseUrl: string | undefined;
-    readonly baseUrl: string;
-    private readonly key;
-    /** Text-to-Speech: vorlesen lassen und abspielen (siehe Doku "TTS") */
-    readonly tts: PixlTts;
-    /** Chat: Emotes als HTML, 7TV-Paints (siehe Doku "Chat") */
-    readonly chat: PixlChat;
-    private handlers;
-    private stateHandlers;
-    private statusHandlers;
-    private states;
-    private _status;
-    private abort;
-    private reconnectTimer;
-    private watchdog;
-    private attempt;
-    private stopped;
-    private readonly logs;
-    private everConnected;
-    private lostAt;
-    constructor(options: PixlOptions);
+    private static sharedInstance;
     /**
-     * Handler für einen Event-Typ registrieren (`"twitch.cheer"`), oder für alle
-     * Events mit `"*"`. Gibt die Instanz zurück, Aufrufe lassen sich verketten.
+     * Gemeinsame Instanz der Seite, damit Bausteine (`@pixl-app/sdk/ui`) und eigener Code
+     * dieselbe Verbindung nutzen. Die erste mit `new Pixl()` erzeugte Instanz ist automatisch
+     * die gemeinsame, sonst entsteht sie hier.
      */
-    on(event: string, handler: EventHandler): this;
-    /** Handler wieder entfernen */
-    off(event: string, handler: EventHandler): this;
+    static shared(options?: PixlOptions): Pixl;
     /**
-     * State abonnieren. Der Handler läuft sofort mit dem aktuellen Wert (sobald
-     * bekannt) und danach bei jeder Änderung.
+     * Schrift laden (Bunny Fonts, dieselben Schriften wie Google Fonts), z.B. eine feste Schrift im
+     * Code. Werte aus `font`-Feldern lädt `pixl.widget()` von selbst. `true`, sobald sie bereit ist,
+     * `false`, wenn es sie dort nicht gibt (dann gilt eine lokal installierte)
      */
-    state(key: string, handler: StateHandler): this;
-    /** State-Handler wieder entfernen */
-    offState(key: string, handler: StateHandler): this;
-    /** Zuletzt bekannter Wert eines States (undefined, solange unbekannt) */
-    getState(key: string): unknown;
-    get status(): PixlStatus;
-    /** Statuswechsel beobachten. Gibt eine Funktion zum Abmelden zurück. */
-    onStatus(handler: (status: PixlStatus) => void): () => void;
-    private setStatus;
-    /** Rohzugriff auf einen /api/v1-Endpoint (Pfad ohne /api/v1, z.B. `/events`) */
-    request<T>(path: string, params?: Record<string, string | undefined>): Promise<T>;
+    static loadFont: typeof loadFont;
     /**
-     * Wie request(), aber mit beliebiger Methode und Body (JSON) bzw. roher
-     * Response. Für die TTS-Endpunkte, nicht Teil der öffentlichen Schnittstelle.
-     * @internal
+     * Wert für CSS `font-family` mit Anführungszeichen und Ausweich-Schrift
+     * @example el.style.fontFamily = Pixl.fontFamily(font) // "Open Sans", sans-serif
      */
-    _fetch(path: string, init?: {
-        method?: string;
-        json?: unknown;
-    }): Promise<Response>;
-    /** Eventlog abfragen (neueste zuerst, seitenweise) */
-    events(query?: EventsQuery): Promise<EventsPage>;
-    /** Infos zur Organisation, der der Schlüssel gehört, plus dessen Scopes */
-    org(): Promise<OrgInfo>;
+    static fontFamily: typeof fontFamily;
+    readonly baseUrl: string;
+    /** true im Demo-Modus (kein Server) */
+    readonly demo: boolean;
+    /** Verbindungsstatus */
+    readonly status: LiveValue<ConnectionStatus>;
+    /** Kanal des Zugangs, null bis zur ersten Verbindung */
+    readonly channel: LiveValue<Channel | null>;
+    /** Erfüllt, sobald die Verbindung steht und alle Live-Werte geladen sind. Schlägt fehl bei ungültigem Zugang. */
+    readonly ready: Promise<void>;
+    /** Historie und Feed (Historie plus live) */
+    readonly events: PixlEvents;
+    /** Sub-Zahl, Hype Train, Umfrage, Vorhersage, Ziel, Spendenaktion, Werbepause */
+    readonly twitch: PixlTwitch;
+    /** Was gerade auf Spotify läuft */
+    readonly spotify: PixlSpotify;
+    /** Text-to-Speech: vorlesen lassen und abspielen */
+    readonly tts: PixlTts;
+    /** Chat: Emotes, Badges, 7TV-Paints */
+    readonly chat: PixlChat;
+    /** Lesender Zugriff auf den verbundenen StreamElements-Kanal */
+    readonly streamElements: PixlStreamElements;
     /**
-     * Aktuelle Sub-Zahl direkt von Twitch, unabhängig vom Eventlog (höchstens 60 s alt).
-     * Braucht einen Schlüssel mit `subs:read`. Änderungen kommen live als `subs.updated`
-     * mit denselben Feldern.
+     * Felder des gehosteten Widgets als einfaches Objekt, immer auf dem aktuellen Stand
+     * (Steuerelemente vor Einstellungen, wie die CSS-Variablen `--pixl-…`). Mit einem normalen
+     * API-Schlüssel leer. Auf Änderungen hören: `pixl.widget().values.name.subscribe(…)`
+     * @example const { text, color } = pixl.fields
      */
-    subs(): Promise<SubCount>;
+    readonly fields: Readonly<Record<string, unknown>>;
+    private key;
+    private readonly logs;
+    private widgetInstance;
+    private readonly control;
+    private readonly previewMode;
+    private readonly fetchImpl;
+    private readonly stream;
+    private readonly statusValue;
+    private readonly channelValue;
+    private readonly handlers;
+    private readonly internal;
+    private readonly connectHandlers;
+    private scopeList;
+    private readonly warnedScopes;
+    private warnedNoWidget;
+    private resolveReady;
+    private rejectReady;
+    private readySettled;
+    constructor(options?: PixlOptions);
     /**
-     * Was gerade auf Spotify läuft: `{ playing, progressMs, at, track, addedBy }`.
-     * Braucht einen Schlüssel mit `spotify:read` und das Modul Musik. Läuft nichts
-     * (kein Gerät aktiv), ist `track` null. Änderungen (anderer Song, Play/Pause,
-     * Sprung im Song) kommen live als `spotify.now_playing` mit denselben Feldern.
-     * Den laufenden Fortschritt liefert `Pixl.progress(nowPlaying)`.
+     * Das gehostete Widget, zu dem der Zugang gehört: Einstellungen, Werte, Knöpfe, Listen.
+     * null mit einem normalen API-Schlüssel (Widgets gibt es nur gehostet).
      */
-    nowPlaying(): Promise<SpotifyNowPlaying>;
+    widget(): PixlWidget | null;
+    /** Rechte des Zugangs, null bis zur ersten Verbindung */
+    get scopes(): readonly string[] | null;
     /**
-     * Fortschritt in ms zum Zeitpunkt `now`, aus einer Messung von `nowPlaying()` bzw.
-     * `spotify.now_playing`. Läuft der Song, wird ab `at` weitergerechnet, höchstens bis
-     * zur Songlänge.
+     * Handler für einen Event-Typ, `"*"` für alle. Gibt eine Funktion zum Abmelden zurück.
+     * @example pixl.on("twitch.raid", (e) => show(`${e.data.user.name} raidet mit ${e.data.viewers}`))
      */
-    static progress(nowPlaying: SpotifyNowPlaying, now?: number): number;
+    on<T extends ChannelEventType>(type: T, handler: (event: PixlEvent<T>) => void): () => void;
+    on(type: "*", handler: (event: PixlEvent) => void): () => void;
     /**
-     * Lesender Zugriff auf den verbundenen StreamElements-Kanal, pixl reicht die
-     * Anfrage mit dem hinterlegten Overlay Token weiter (der Token bleibt bei pixl).
-     * Braucht einen Schlüssel mit `streamelements:read`. `params` gehen 1:1 als
-     * Query-Parameter an StreamElements, die Antwort kommt unverändert zurück.
+     * Ein Event nur an diese Instanz schicken, mit der Vorlage des Typs und eigenen Feldern.
+     * `source` ist `test`. Geht auch ohne Verbindung und im Demo-Modus.
+     * @example pixl.sendTestEvent("twitch.raid", { viewers: 50 })
      */
-    streamElements<T = unknown>(path: StreamElementsProxyPath, params?: Record<string, string | number | undefined>): Promise<T>;
-    /** Aktuelle Werte aller States */
-    fetchStates(): Promise<Record<string, unknown>>;
+    sendTestEvent<T extends ChannelEventType>(type: T, overrides?: Partial<EventPayloads[T]>): PixlEvent<T>;
+    /** Live-Verbindung aufbauen (passiert standardmäßig automatisch) */
+    connect(): void;
+    /** Verbindung trennen, alle Handler und Abonnements entfernen */
+    close(): void;
     /**
-     * Alle Events seit `since` holen, über alle Seiten hinweg, älteste zuerst.
-     * Für große Zeiträume entsprechend viele Requests (200 Events pro Seite).
+     * Rohzugriff auf `/api/v1` mit Zugang und Fehlerbehandlung, für alles ohne eigenen Bereich.
+     * @example await pixl.request("/subs")
      */
-    fetchAllEvents(query?: Omit<EventsQuery, "cursor" | "limit">): Promise<EventsPage["events"]>;
+    request<T>(path: string, options?: RequestOptions): Promise<T>;
+    /** @internal Antwort als Response (Audio, Blobs) */
+    fetchRaw(path: string, options?: RequestOptions): Promise<Response>;
+    /** @internal Bereiche laden beim Verbinden ihren Stand (läuft bei jedem `connected`) */
+    _onConnect(fn: () => Promise<unknown> | void): void;
+    /** @internal Wie on(), aber ohne Scope-Warnung, für Bereiche des SDK */
+    _listen<T extends ChannelEventType>(type: T, handler: (event: PixlEvent<T>) => void): () => void;
+    private widgetOptions;
     /**
-     * Historie + live in einem: `handler` bekommt erst alle Events seit `since`
-     * (älteste zuerst, `event.history === true`), danach jedes neue live. Jedes
-     * Event kommt genau einmal an, auch über Verbindungsabbrüche hinweg.
-     * Rechnet selbst nichts, Summen o.ä. baut der Aufrufer im Handler.
+     * @internal Vorschau im Arbeitsplatz von pixl: Vorlesen läuft dort über eigene Wege und ist nur in der
+     * Vorschau zu hören (PixlTts)
      */
-    feed(options: FeedOptions, handler: EventHandler): EventFeed;
-    /** Live-Stream verbinden (passiert standardmäßig automatisch) */
-    connect(): void;
-    /** Stream trennen und nicht neu verbinden */
-    disconnect(): void;
-    private run;
-    private log;
-    private scheduleReconnect;
-    private armWatchdog;
-    private clearWatchdog;
-    private readStream;
+    get _preview(): boolean;
+    /** @internal */
+    _log(message: string): void;
+    private handleMessage;
+    private handleWidgetMessage;
+    private listenToDashboard;
+    private handleConnected;
+    private handleStatus;
     private dispatch;
-    private emit;
-    private setState;
+    private checkScope;
+    private log;
 }

package/dist/errors.d.ts

@@ -0,0 +1,17 @@
+export type PixlErrorCode = "unauthorized" | "forbidden" | "missing_scope" | "module_disabled" | "rate_limited" | "not_found" | "invalid" | "network" | "demo" | "server";
+export declare class PixlError extends Error {
+    readonly code: PixlErrorCode;
+    /** HTTP-Status, falls es eine Antwort gab */
+    readonly status?: number;
+    /** Fehlender Scope bei `missing_scope` */
+    readonly scope?: string;
+    /** Zusätzlicher Grund vom Server, z.B. `quota` bei TTS */
+    readonly problem?: string;
+    constructor(code: PixlErrorCode, message: string, extra?: {
+        status?: number;
+        scope?: string;
+        problem?: string;
+    });
+}
+/** @internal Fehler aus einer HTTP-Antwort */
+export declare function errorFromResponse(res: Response): Promise<PixlError>;

package/dist/events.d.ts

@@ -0,0 +1,41 @@
+import type { ChannelEventType } from "./api-types/index.js";
+import type { Pixl, PixlEvent } from "./client.js";
+import { EventFeed, type FeedOptions } from "./feed.js";
+export type { FeedOptions };
+/** Zeitpunkt: Date, ISO-String, Unix-ms oder `"stream"` (Start des letzten Streams) */
+export type Since = Date | string | number;
+export type HistoryQuery = {
+    /** Ab wann, Pflicht, damit nicht versehentlich das ganze Eventlog geladen wird */
+    since: Since;
+    /** Bis wann (exklusiv) */
+    until?: Date | string | number;
+    /** Nur diese Event-Typen */
+    types?: ChannelEventType[];
+    signal?: AbortSignal;
+};
+type Page = {
+    events: PixlEvent[];
+    nextCursor: string | null;
+};
+/** @internal */
+export declare function toQueryDate(value: Since): string;
+export declare class PixlEvents {
+    private readonly pixl;
+    constructor(pixl: Pixl);
+    /**
+     * Eventlog seit `since`, neueste zuerst, blättert selbst. Enthält nur Events, die im
+     * Eventlog stehen (keine Chat-Nachrichten, keine Zwischenstände). Scope `events:read`.
+     * @example for await (const e of pixl.events.list({ since: "stream" })) …
+     */
+    list(query: HistoryQuery): AsyncGenerator<PixlEvent, void, undefined>;
+    /** Wie `list()`, aber alles auf einmal und älteste zuerst */
+    all(query: HistoryQuery): Promise<PixlEvent[]>;
+    /**
+     * Historie plus live in einem: `handler` bekommt erst alle Events seit `since` (älteste
+     * zuerst, `source: "history"`), danach jedes neue. Jedes Event genau einmal, auch über
+     * Verbindungsabbrüche hinweg. Rechnet nichts, Summen baut der Handler.
+     */
+    feed(options: FeedOptions, handler: (event: PixlEvent) => void): EventFeed;
+    /** @internal Eine Seite der Historie */
+    fetchPage(query: HistoryQuery, cursor?: string): Promise<Page>;
+}

package/dist/feed.d.ts

@@ -1,51 +1,43 @@
-import type { EventHandler, Pixl } from "./client.js";
+import type { ChannelEventType } from "./api-types/index.js";
+import type { Pixl, PixlEvent } from "./client.js";
+import type { PixlEvents, Since } from "./events.js";
+import { type LiveValue } from "./live-value.js";
+import { PixlError } from "./errors.js";
 export type FeedOptions = {
-    /**
-     * Ab wann die Historie geladen wird: Date, ISO-String, Unix-ms oder `"stream"`
-     * (Start des letzten Streams). Pflicht, damit nicht versehentlich das
-     * komplette Eventlog geladen wird.
-     */
-    since: Date | string | number;
+    /** Ab wann die Historie geladen wird, Pflicht (z.B. `"stream"`) */
+    since: Since;
     /** Nur diese Event-Typen (Historie und live) */
-    types?: string[];
+    types?: ChannelEventType[];
 };
 /**
- * Historie + live, jedes Event genau einmal. Ablauf bei jedem (Re-)Connect:
+ * Historie plus live, jedes Event genau einmal. Ablauf bei jedem (Neu-)Verbinden:
  * 1. Live-Events ab jetzt puffern (der Stream steht bereits)
  * 2. Historie seit `since` laden und ausliefern, was noch nicht ausgeliefert ist
  * 3. Puffer abarbeiten, Doppelte (gleiche ID) überspringen, danach direkt live
- * Weil nach jedem Reconnect die Historie erneut abgeglichen wird, gehen auch
- * Events aus einer Verbindungslücke nicht verloren. Nach dem ersten Laden reichen
- * dafür die neuesten Seiten: geblättert wird nur bis kurz vor das neueste schon
- * ausgelieferte Event. Sonst lüde jedes Overlay nach einem Deploy die komplette
- * Historie seit `since` neu und liefe dabei ins Rate-Limit.
- * Schlägt das Laden fehl, wird es mit Backoff wiederholt, solange der Stream steht.
- *
- * Bewusst ohne jede Auswertung: was der Handler mit den Events macht (Summen,
- * Listen, Alerts), entscheidet der Aufrufer.
+ * Nach dem ersten Laden wird nur bis kurz vor das neueste ausgelieferte Event geblättert,
+ * sonst lüde jedes Overlay nach einem Deploy die ganze Historie neu (Rate-Limit).
  */
 export declare class EventFeed {
-    /** true, sobald die Historie einmal komplett ausgeliefert wurde */
-    ready: boolean;
-    /** Letzter Fehler beim Laden der Historie */
-    error: Error | null;
     private readonly pixl;
+    private readonly events;
+    private readonly handler;
+    /** true, sobald die Historie einmal komplett ausgeliefert wurde */
+    readonly ready: LiveValue<boolean>;
+    /** Letzter Fehler beim Laden der Historie, null wenn alles gut ging */
+    readonly error: LiveValue<PixlError | null>;
+    private readonly readyValue;
+    private readonly errorValue;
     private readonly since;
     private readonly types;
-    private readonly handler;
     private readonly delivered;
-    private readonly errorListeners;
     private buffer;
     private loadSeq;
     private stopped;
     private latestAt;
     private retryTimer;
     private retryAttempt;
-    private readonly unsubscribeStatus;
-    private readonly onEvent;
-    constructor(pixl: Pixl, options: FeedOptions, handler: EventHandler);
-    /** Fehler beim Laden der Historie beobachten (z.B. noch nie gestreamt bei since="stream") */
-    onError(listener: (error: Error) => void): () => void;
+    private readonly unsubscribe;
+    constructor(pixl: Pixl, events: PixlEvents, options: FeedOptions, handler: (event: PixlEvent) => void);
     /** Feed beenden, der Handler wird danach nicht mehr aufgerufen */
     stop(): void;
     private load;

package/dist/fonts.d.ts

@@ -0,0 +1,19 @@
+import type { WidgetState } from "./api-types/index.js";
+/** Woher `loadFont` lädt */
+export declare const FONT_HOST = "https://fonts.bunny.net";
+/** Adresse des Stylesheets einer Schrift bei Bunny Fonts, mit allen Stärken */
+export declare function fontStylesheetUrl(family: string): string;
+/**
+ * Wert für CSS `font-family`: der Name in Anführungszeichen, dahinter eine Ausweich-Schrift.
+ * Leer → nur die Ausweich-Schrift.
+ * @example el.style.fontFamily = fontFamily(widget.get("font")) // "Open Sans", sans-serif
+ */
+export declare function fontFamily(family: string | null | undefined, fallback?: string): string;
+/**
+ * Schrift von Bunny Fonts laden (jede nur einmal). Erfüllt sich, sobald sie bereit ist, mit
+ * `true`, oder mit `false`, wenn Bunny Fonts sie nicht hat (dann gilt eine lokal installierte
+ * Schrift dieses Namens). Werte aus `font`-Feldern lädt `pixl.widget()` von selbst.
+ */
+export declare function loadFont(family: string): Promise<boolean>;
+/** Namen aus allen `font`-Feldern eines Stands, auch aus Einträgen von Listen */
+export declare function fontsOf(state: WidgetState | null): string[];

package/dist/frame.d.ts

@@ -0,0 +1,2 @@
+/** @internal */
+export declare function startFrameBridge(): void;