@pixl-app/sdk 0.1.0 → 1.0.0

package/dist/api-types/widgets.d.ts

@@ -0,0 +1,555 @@
+/**
+ * Eine Aktion für den gewählten Eintrag einer Liste am Stream Deck. Dieselben Operationen wie
+ * bei `widget.batch` für ein Feld eines Eintrags, ohne `name` und `update`: `toggle` (boolean),
+ * `add` (number), `next` (enum), jeweils mit `field`, oder `patch` (feste Werte für Felder)
+ */
+export type StreamDeckItemAction = {
+    label: string;
+    field: string;
+    toggle: true;
+} | {
+    label: string;
+    field: string;
+    add: number;
+} | {
+    label: string;
+    field: string;
+    next: true;
+} | {
+    label: string;
+    patch: Record<string, unknown>;
+};
+/** Grenzen für `streamdeck.actions` an Listen */
+export declare const STREAMDECK_ACTION_LIMITS: {
+    readonly actions: 10;
+    readonly labelLength: 30;
+};
+/**
+ * Stream Deck an einem Feld: nur bei Listen die Aktionen. Wie Tasten und Regler aussehen,
+ * bestimmt immer pixl (einheitliche Symbole), eigene Bilder für Felder gibt es nicht. Nur die
+ * Einträge einer Liste dürfen eigene Bilder haben (`itemImage`, `item(ctx)` in streamdeck.js)
+ */
+export type StreamDeckDisplay = {
+    /**
+     * Nur `list`: was Taste und Regler mit dem gewählten Eintrag tun können, die erste ist der
+     * Standard. Ohne `actions` erscheint die Liste nicht am Stream Deck
+     */
+    actions?: StreamDeckItemAction[];
+};
+type FieldBase = {
+    label: string;
+    description?: string;
+    /** Abschnitt auf der Steuer-Seite bzw. im Formular */
+    group?: string;
+    /** Nur per SDK setzbar, nicht im Dashboard und nicht am Stream Deck */
+    hidden?: boolean;
+    /** Stream Deck: bei Listen die Aktionen für einen Eintrag */
+    streamdeck?: StreamDeckDisplay;
+};
+/** Ja oder nein (Schalter) */
+export type BooleanField = FieldBase & {
+    type: "boolean";
+    default?: boolean;
+};
+/**
+ * Zahl. `step` wie bei HTML: Standard 1, also ganze Zahlen, für Kommazahlen z.B. `0.1`. Im Dashboard
+ * Plus und Minus, mit `slider` ein Schieberegler (dann sind `min` und `max` Pflicht)
+ */
+export type NumberField = FieldBase & {
+    type: "number";
+    min?: number;
+    max?: number;
+    step?: number;
+    default?: number;
+    slider?: boolean;
+};
+/**
+ * Text, mit `multiline` mehrzeilig. Mit `sensitive` ein Geheimnis wie ein API-Schlüssel: im Dashboard
+ * verdeckt, den Wert bekommen nur das Widget selbst und wer Widgets verwaltet. Nur direkt unter
+ * `settings`, immer einzeilig, ohne `default` (pixl.json liegt offen im Bundle)
+ */
+export type StringField = FieldBase & {
+    type: "string";
+    maxLength?: number;
+    multiline?: boolean;
+    sensitive?: boolean;
+    default?: string;
+};
+/** Farbe als `#RRGGBB` oder `#RRGGBBAA` */
+export type ColorField = FieldBase & {
+    type: "color";
+    default?: string;
+};
+/** Eine von festen Optionen */
+export type EnumField = FieldBase & {
+    type: "enum";
+    options: string[];
+    default?: string;
+};
+/**
+ * Datei aus den Uploads des Kanals (`/files/…`) oder eine https-URL. `accept` wie beim HTML-Attribut:
+ * MIME-Typen (`image/png`), Gruppen (`image/*`) und Endungen (`.mp3`), mit Komma getrennt
+ */
+export type FileField = FieldBase & {
+    type: "file";
+    accept: string;
+    default?: string;
+};
+/**
+ * Schriftart als Name der Familie (`"Open Sans"`). Das Dashboard schlägt Google Fonts vor, eigene
+ * Namen gehen auch (z.B. eine in OBS installierte Schrift). Leer = Schrift des Widgets.
+ * Gehostete Widgets laden den Wert über das SDK von selbst (Bunny Fonts, gleiche Schriften wie Google Fonts)
+ */
+export type FontField = FieldBase & {
+    type: "font";
+    default?: string;
+};
+/**
+ * TTS-Stimme als ID wie bei `POST /api/v1/tts` (`"polly:hans"`, `"fish:<uuid>"`). Das Dashboard
+ * zeigt die Stimmen des Kanals mit Namen zur Auswahl. Leer = die Stimme aus den TTS-Einstellungen
+ * des Kanals, der Wert lässt sich also immer direkt als `voice` übergeben. `default` nur mit einer
+ * festen Standardstimme (`polly:…`), Katalog- und eigene Stimmen haben in jedem Kanal andere IDs
+ */
+export type VoiceField = FieldBase & {
+    type: "voice";
+    default?: string;
+};
+/** Kein Wert, sondern ein Ereignis: das Widget bekommt `widget.action`. Nur unter `controls` */
+export type TriggerField = FieldBase & {
+    type: "trigger";
+};
+/** Felder, die ein Eintrag einer Liste haben kann */
+export type ListItemField = BooleanField | NumberField | StringField | ColorField | EnumField | FileField | FontField | VoiceField;
+export type ListItemFieldType = ListItemField["type"];
+/** Liste von Einträgen mit den Feldern aus `item`, jeder Eintrag bekommt vom Server eine feste `id` */
+export type ListField = FieldBase & {
+    type: "list";
+    item: Record<string, ListItemField>;
+    /** Höchstens so viele Einträge */
+    max?: number;
+    /** Feld, das Dashboard und Stream Deck als Namen eines Eintrags zeigen */
+    itemLabel?: string;
+    /** `file`-Feld mit dem Bild eines Eintrags */
+    itemImage?: string;
+};
+export type WidgetField = ListItemField | TriggerField | ListField;
+export type WidgetFieldType = WidgetField["type"];
+/** Einstellungen: alles außer `trigger` */
+export type SettingField = Exclude<WidgetField, TriggerField>;
+/** Inhalt von pixl.json */
+export type WidgetManifest = {
+    name?: string;
+    /** Größe in Pixeln, so groß legt man die Browserquelle in OBS an (Vorschau im Dashboard ebenso) */
+    width?: number;
+    height?: number;
+    /** Aussehen und Verhalten, selten geändert, nur im Dashboard */
+    settings?: Record<string, SettingField>;
+    /** Für den laufenden Stream, im Dashboard und am Stream Deck */
+    controls?: Record<string, WidgetField>;
+    /**
+     * Eigene Steuer-Seiten im Bundle. Eine als Pfad (`"control.html"`) oder mehrere als Reiter
+     * im Dashboard (`[{ "label": "Aufgaben", "page": "control.html" }, …]`)
+     */
+    control?: string | WidgetControlPage[];
+    /** Eigene Bilder für Einträge von Listen am Stream Deck (Skript im Bundle) */
+    streamdeck?: StreamDeckWidget;
+};
+/**
+ * Stream Deck auf oberster Ebene der pixl.json. `script`: Pfad im Bundle (z.B. `"streamdeck.js"`),
+ * ein ES-Modul mit `item(ctx)`, das das Bild eines Listeneintrags zeichnet (Kachel im Karussell
+ * am Regler). Alles andere zeichnet immer pixl, ohne Skript auch die Einträge (`itemImage`).
+ */
+export type StreamDeckWidget = {
+    script?: string;
+};
+/** Eine eigene Steuer-Seite, im Dashboard ein Reiter */
+export type WidgetControlPage = {
+    label: string;
+    page: string;
+};
+/** Ein Eintrag einer Liste, `id` vergibt der Server */
+export type ListItem = {
+    id: string;
+    [field: string]: unknown;
+};
+/** Werte, Name des Felds → Wert */
+export type WidgetValues = Record<string, unknown>;
+/**
+ * Änderung an einem Feld. Listen immer über die `id` des Eintrags. Auf ein Feld eines Eintrags
+ * wirken dieselben Operationen wie auf ein Feld oben, dazu `update` (id) und `field` (Name)
+ */
+export type WidgetOperation = 
+/** Wert setzen (alle Typen außer `trigger`, bei `list` die ganze Liste) */
+{
+    name: string;
+    set: unknown;
+}
+/** `number`: um `add` ändern, bleibt in `min`/`max` */
+ | {
+    name: string;
+    add: number;
+}
+/** `boolean`: umschalten */
+ | {
+    name: string;
+    toggle: true;
+}
+/** `enum`: nächste Option, nach der letzten wieder die erste */
+ | {
+    name: string;
+    next: true;
+}
+/** `trigger`: auslösen */
+ | {
+    name: string;
+    press: true;
+} | {
+    name: string;
+    insert: Record<string, unknown>;
+    at?: number;
+} | {
+    name: string;
+    update: string;
+    patch: Record<string, unknown>;
+} | {
+    name: string;
+    update: string;
+    field: string;
+    add: number;
+} | {
+    name: string;
+    update: string;
+    field: string;
+    toggle: true;
+} | {
+    name: string;
+    update: string;
+    field: string;
+    next: true;
+} | {
+    name: string;
+    remove: string;
+} | {
+    name: string;
+    move: string;
+    to: number;
+};
+/** Wo ein Feld liegt */
+export type WidgetFieldScope = "settings" | "controls";
+/** Was sich durch eine Operation geändert hat, so kommt es live an */
+export type WidgetChange = {
+    scope: WidgetFieldScope;
+    name: string;
+    value: unknown;
+} | {
+    scope: WidgetFieldScope;
+    name: string;
+    inserted: ListItem;
+    at: number;
+} | {
+    scope: WidgetFieldScope;
+    name: string;
+    updated: ListItem;
+} | {
+    scope: WidgetFieldScope;
+    name: string;
+    removed: string;
+} | {
+    scope: WidgetFieldScope;
+    name: string;
+    moved: string;
+    to: number;
+};
+/** Stand eines Widgets beim Verbinden */
+export type WidgetState = {
+    id: string;
+    name: string;
+    version: string | null;
+    manifest: WidgetManifest | null;
+    settings: WidgetValues;
+    values: WidgetValues;
+};
+/** Werte oder Einstellungen haben sich geändert */
+export type StreamWidgetChanged = {
+    type: "widget.changed";
+    changes: WidgetChange[];
+};
+/** Ein `trigger` wurde ausgelöst */
+export type StreamWidgetAction = {
+    type: "widget.action";
+    name: string;
+};
+/** Eine andere Code-Version ist aktiv, gehostete Widgets laden neu */
+export type StreamWidgetVersion = {
+    type: "widget.version";
+    version: string | null;
+};
+export type StreamWidgetMessage = StreamWidgetChanged | StreamWidgetAction | StreamWidgetVersion;
+/**
+ * Ein Widget, wie es eine verbundene App (Stream Deck) bekommt:
+ * GET /api/v1/channels/<kanal>/widgets. Nie mit Schlüssel, OBS-Adresse oder Einstellungen.
+ * Bildverweise auflösen: beginnt mit `https://` oder `http://` → so nehmen, beginnt mit
+ * `/files/` → `files` davor, sonst → `assets` davor (fehlt die Basis, gibt es kein Bild).
+ */
+export type DeviceWidget = {
+    id: string;
+    name: string;
+    version: string | null;
+    /** `controls` aus pixl.json ohne `hidden`-Felder, `{}` ohne Manifest */
+    controls: Record<string, WidgetField>;
+    /** Aktuelle Werte genau dieser Steuerelemente */
+    values: WidgetValues;
+    /** Absolute Basis-URL der aktiven Version mit `/` am Ende, null ohne Version oder Widget-Adresse */
+    assets: string | null;
+    /** Widget-Adresse ohne `/` am Ende, für Werte wie `/files/…`, null ohne Widget-Adresse */
+    files: string | null;
+    /**
+     * Absolute URL von `streamdeck.script` in der aktiven Version (`assets` + Pfad), null ohne
+     * Skript, Version oder Widget-Adresse. Bei `widget.version` neu laden.
+     */
+    script: string | null;
+};
+/** Erste Nachricht auf GET /api/v1/channels/<kanal>/stream?topics=widgets */
+export type DeviceStreamConnected = {
+    type: "connected";
+    channel: string;
+};
+/** Steuerelemente eines Widgets haben sich geändert. Mit `refetch` den Stand neu laden */
+export type DeviceWidgetChanged = {
+    type: "widget.changed";
+    widgetId: string;
+    changes: WidgetChange[];
+    refetch?: true;
+};
+/** Andere Code-Version aktiv: Widgets neu laden (Felder und Bilder können anders sein) */
+export type DeviceWidgetVersion = {
+    type: "widget.version";
+    widgetId: string;
+    version: string | null;
+};
+/** Widget angelegt, umbenannt oder gelöscht: Widgets neu laden */
+export type DeviceWidgetsUpdated = {
+    type: "widgets.updated";
+    widgetId: string;
+};
+export type DeviceStreamMessage = DeviceStreamConnected | DeviceWidgetChanged | DeviceWidgetVersion | DeviceWidgetsUpdated;
+/** Grenzen für pixl.json */
+export declare const WIDGET_LIMITS: {
+    readonly fields: 50;
+    readonly listItems: 200;
+    readonly nameLength: 64;
+    readonly labelLength: 80;
+    readonly textLength: 2000;
+    readonly controlPages: 5;
+    /** Länge des Namens einer Schriftart (`font`) */
+    readonly fontLength: 100;
+};
+/**
+ * Was `item(ctx)` in streamdeck.js bekommt: ein Eintrag einer Liste, gezeichnet als Kachel im
+ * Karussell am Regler. Nur Daten, alles JSON. Das Plugin ruft die Funktion neu auf, wenn sich der
+ * Eintrag ändert oder er gewählt bzw. nicht mehr gewählt ist, und merkt sich das Ergebnis sonst.
+ */
+export type StreamDeckItemContext = {
+    /** Immer `"item"` */
+    kind: "item";
+    /** Größe der Kachel in Pixeln (quadratisch). Nachbarn verkleinert und abgedunkelt pixl selbst */
+    size: number;
+    widget: {
+        id: string;
+        name: string;
+    };
+    /** Name der Liste in `controls` */
+    name: string;
+    /** Die Liste aus pixl.json */
+    field: ListField;
+    /** Der Eintrag mit seiner `id` */
+    item: ListItem;
+    /** Stelle in der Liste (ab 0) und Anzahl der Einträge */
+    index: number;
+    count: number;
+    /** Gerade gewählt (die Kachel in der Mitte) */
+    selected: boolean;
+    /** Feld der Einträge, das die eingestellte Aktion aus `streamdeck.actions` ändert (z.B. `"done"`). Fehlt bei `patch` */
+    itemField?: string;
+    /** Ob dieses Feld an ist (z.B. erledigt). Nur, wenn es ein `boolean` ist */
+    done?: boolean;
+};
+/**
+ * Das Modul streamdeck.js mit `item(ctx)`. Ein String ist ein vollständiges SVG-Dokument für die
+ * Kachel (`ctx.size` × `ctx.size`, z.B. mit `pixl.svg`), `null`/`undefined` (oder ein Fehler)
+ * heißt: pixl zeichnet die Kachel selbst (Bild aus `itemImage`, Name, Haken)
+ */
+export type StreamDeckScript = {
+    item?: (ctx: StreamDeckItemContext) => string | null | undefined;
+};
+/** Eine Kachel in `pixl.carousel` */
+export type StreamDeckSlot = {
+    /** Index des Eintrags */
+    index: number;
+    /**
+     * Abstand zur angezeigten Stelle, 0 = Mitte, negativ = links. Beim Blättern mit
+     * Nachkommastellen (z.B. `-0.4`)
+     */
+    offset: number;
+    /** Linke obere Ecke der Kachel */
+    x: number;
+    y: number;
+    /** Kantenlänge der Kachel */
+    size: number;
+    /** Helligkeit wie früher als Deckkraft (1 = Mitte), nur noch zur Info */
+    opacity: number;
+    /**
+     * Abdunkelung der Kachel, 0 = hell (Mitte) bis 1 = schwarz. Innerhalb von `render` dunkeln
+     * pixl.img, pixl.image, pixl.rect und pixl.text von selbst um diesen Wert ab
+     */
+    shade: number;
+    /** Ist das die Kachel, die der Mitte am nächsten ist? */
+    center: boolean;
+};
+export type StreamDeckTextOptions = {
+    x: number;
+    y: number;
+    /** Schriftgröße, Standard 14 */
+    size?: number;
+    /** Standard `"#fff"` */
+    color?: string;
+    /** Standard `"middle"` */
+    anchor?: "start" | "middle" | "end";
+    /** Standard `"normal"` */
+    weight?: "normal" | "bold" | number;
+    /** Standard 1 */
+    opacity?: number;
+};
+export type StreamDeckImageOptions = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    opacity?: number;
+};
+export type StreamDeckRectOptions = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Eckenradius, Standard 0 */
+    rx?: number;
+    fill?: string;
+    opacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+};
+export type StreamDeckBarOptions = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color?: string;
+    background?: string;
+};
+export type StreamDeckDotsOptions = {
+    /** Mitte der Punkte, Standard 100 (Mitte am Regler). Auf Tasten `ctx.width / 2` */
+    x?: number;
+    y: number;
+    /** Abstand der Punkte, Standard 9 */
+    gap?: number;
+    /** Höchstens so viele Punkte, bei mehr Einträgen wandert das Fenster mit. Standard 9 */
+    max?: number;
+    color?: string;
+    activeColor?: string;
+};
+export type StreamDeckCarouselOptions = {
+    /** Anzahl Einträge */
+    count: number;
+    /**
+     * Stelle in der Mitte. Darf Nachkommastellen haben, dann liegen die Kacheln dazwischen und
+     * Größe und Deckkraft gehen fließend über. Am Regler `ctx.position ?? ctx.selected` übergeben,
+     * dann gleitet das Karussell beim Drehen
+     */
+    selected: number;
+    /** Fläche, Standard 200 × 100 */
+    width?: number;
+    height?: number;
+    /** Senkrechte Mitte der Kacheln, Standard height / 2 */
+    y?: number;
+    /** Kantenlänge der mittleren Kachel, Standard 70 */
+    size?: number;
+    /** Abstand zwischen den Kacheln, negativ = überlappend wie in Elgatos Aktionsrad, Standard -12 */
+    gap?: number;
+    /** Größe der Nachbarn im Verhältnis zur Mitte, Standard 0.8 */
+    sideScale?: number;
+    /** Helligkeit der Nachbarn (gleich für alle, nicht durchsichtig), Standard 0.75. img, rect und text in `render` dunkeln von selbst ab (PNG und JPEG Pixel für Pixel, SVG nicht) */
+    fade?: number;
+    /** Im Kreis: nach dem letzten Eintrag kommt der erste, Standard true */
+    wrap?: boolean;
+    /** So viele Nachbarn je Seite, Standard 1 wie bei Elgato. Beim Gleiten kommt außen der nächste herein */
+    radius?: number;
+    /** Inhalt einer Kachel als SVG-Fragment */
+    render: (index: number, slot: StreamDeckSlot) => string;
+};
+/** Farben von pixl, `pixl.colors` */
+export type StreamDeckColors = {
+    bg: string;
+    fg: string;
+    text: string;
+    muted: string;
+    ok: string;
+    warn: string;
+};
+/**
+ * Das globale Objekt `pixl` in streamdeck.js. Alle Funktionen liefern SVG als Text,
+ * Texte werden darin schon maskiert.
+ */
+export type StreamDeckPresets = {
+    /**
+     * Adresse für ein Bild: Pfad im Bundle (relativ zur Version), `/files/…` aus den Uploads oder
+     * https-URL. Liefert einen Platzhalter, den das Plugin nach dem Zeichnen durch das Bild ersetzt.
+     * Ist das Bild noch nicht geladen, kommt `""` und das Plugin zeichnet neu, sobald es da ist.
+     * Höchstens 64 verschiedene Bilder pro Aufruf.
+     */
+    image(ref: string): string;
+    /** Text für SVG maskieren (`&`, `<`, `>`, `"`, `'`) */
+    esc(text: unknown): string;
+    /** Kürzen mit `…` am Ende, höchstens `max` Zeichen */
+    truncate(text: unknown, max: number): string;
+    /** Vollständiges `<svg>` mit `xmlns` und `xmlns:xlink` */
+    svg(width: number, height: number, body: string): string;
+    /** `<text>`, der Text wird maskiert */
+    text(str: unknown, options: StreamDeckTextOptions): string;
+    /**
+     * `<image>` mit `href` und `xlink:href`, `""` solange das Bild nicht geladen ist. Das Stream Deck
+     * kennt kein `preserveAspectRatio`, Bilder werden auf Breite und Höhe gestreckt.
+     */
+    img(ref: string, options: StreamDeckImageOptions): string;
+    rect(options: StreamDeckRectOptions): string;
+    /** Fortschrittsbalken, `fraction` von 0 bis 1 */
+    bar(fraction: number, options: StreamDeckBarOptions): string;
+    /** Punkte für die Position in einer Liste, `selected` darf Nachkommastellen haben (hervorgehoben wird der nächste) */
+    dots(count: number, selected: number, options: StreamDeckDotsOptions): string;
+    /** Karussell: ruft `render` für die sichtbaren Einträge um `selected` auf (auch zwischen zwei Einträgen) */
+    carousel(options: StreamDeckCarouselOptions): string;
+    colors: StreamDeckColors;
+    /** Hex-Farbe um `amount` (0 bis 1) Richtung Schwarz, für eigene Farben auf abgedunkelten Kacheln */
+    darken(color: string, amount: number): string;
+    /** Das SVG, das das Plugin ohne Skript für diesen Aufruf zeichnen würde */
+    default(): string;
+};
+/** Grenzen für streamdeck.js */
+export declare const STREAMDECK_SCRIPT_LIMITS: {
+    /** Größe des Skripts in Byte */
+    readonly sourceBytes: number;
+    /** Rechenzeit pro Aufruf von item in ms */
+    readonly callMs: 50;
+    /** Rechenzeit für das Laden des Moduls in ms */
+    readonly evalMs: 200;
+    readonly memoryBytes: number;
+    /** Klein genug, dass QuickJS vor dem Stack von Node aufgibt */
+    readonly stackBytes: number;
+    /** Länge des zurückgegebenen SVG in Byte */
+    readonly outputBytes: number;
+    /** Verschiedene Bilder pro Aufruf */
+    readonly images: 64;
+    /** So viele Fehler hintereinander, dann bleibt das Skript bis zur nächsten Version aus */
+    readonly failures: 5;
+};
+export {};

package/dist/bindings.d.ts

@@ -0,0 +1,22 @@
+import type { WidgetField, WidgetState } from "./api-types/index.js";
+type Bindable = Exclude<WidgetField, {
+    type: "list" | "trigger" | "voice";
+}>;
+/** Name des Felds als CSS-Variable: `accentColor` → `--pixl-accent-color` */
+export declare function cssVarName(name: string): string;
+/** Wert eines Felds als CSS-Wert, null = Variable entfernen */
+export declare function cssValue(field: WidgetField, value: unknown, fileUrl: (path: string) => string): string | null;
+/** Alle Felder, die in die Seite dürfen, Name → Feld und Wert (Steuerelemente vor Einstellungen) */
+export declare function bindableFields(state: WidgetState): Map<string, {
+    field: Bindable;
+    value: unknown;
+}>;
+/** Hält die CSS-Variablen auf dem Stand des Widgets, `apply` nach jeder Änderung aufrufen */
+export declare class PageBindings {
+    private readonly doc;
+    private readonly fileUrl;
+    private vars;
+    constructor(doc: Document, fileUrl: (path: string) => string);
+    apply(state: WidgetState): void;
+}
+export {};

package/dist/chat.d.ts

@@ -41,7 +41,7 @@ export declare class PixlChat {
     badgesHtml(badges?: ChatBadge[]): string;
     /** CSS für einen Namen mit 7TV-Paint (siehe `paintCss`) */
     paintCss(paint: SevenTvPaint, fallback?: string): string;
-    /** HTML einer Nachricht (dasselbe wie `data.html` bei `twitch.chat_message`) */
+    /** HTML einer Nachricht, wie `data.html` bei `twitch.chat_message`, aber z.B. in anderer Größe */
     html(text: string, emotes?: Record<string, ChatEmote>, options?: ChatHtmlOptions): string;
     /** Alle Emotes des Kanals (7TV, BTTV, FFZ, Kanal und global), Gewinner bei gleichem Namen zuerst */
     emotes(): Promise<ChatEmote[]>;