@rocketman-streamkit/types 1.0.0

package/README.md

@@ -0,0 +1,182 @@
+# @rocketman-streamkit/types
+
+TypeScript declarations for the **StreamKit+** integration addon sandbox API.
+
+Use this package when developing worker addons outside the StreamKit+ repository. It provides global typings for `network`, `events`, `permissions`, `dashboard`, `GenerateConfig`, and the rest of the VM sandbox surface — the same declarations that StreamKit+ generates from its internal API source.
+
+> **Version sync:** package version matches the StreamKit+ app release it was built from. Install a version that corresponds to the StreamKit+ build your addon targets.
+
+---
+
+## Installation
+
+```bash
+npm install --save-dev @rocketman-streamkit/types
+```
+
+Or with yarn / pnpm:
+
+```bash
+yarn add -D @rocketman-streamkit/types
+pnpm add -D @rocketman-streamkit/types
+```
+
+---
+
+## Setup
+
+Addon worker code runs inside a VM with **global** sandbox APIs — no `import` of the SDK at runtime. TypeScript only needs the declaration file for editor checks and `tsc --noEmit`.
+
+### Recommended `tsconfig.json`
+
+```json
+{
+  "compilerOptions": {
+    "types": [],
+    "lib": ["ES2020"],
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["./**/*.ts", "./node_modules/@rocketman-streamkit/types/addon.d.ts"]
+}
+```
+
+Alternatively, reference the package types field directly:
+
+```json
+{
+  "compilerOptions": {
+    "types": ["@rocketman-streamkit/types"],
+    "lib": ["ES2020"],
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["./**/*.ts"]
+}
+```
+
+Do **not** add `@types/node` — addon workers are not Node.js processes.
+
+---
+
+## Examples
+
+### HTTP endpoint
+
+Register a POST handler exposed at `http://localhost:{port}/addon/{yourAddonId}/hook`:
+
+```typescript
+network.endpoints.create('hook', 'POST', 'onHook');
+
+events.On('onHook', ({ body, query, params }) => {
+  console.log('Incoming webhook', body);
+  return { ok: true };
+});
+```
+
+### Settings schema
+
+Call `GenerateConfig` once at addon load to register settings fields shown in the StreamKit+ UI:
+
+```typescript
+await GenerateConfig([
+  {
+    key: 'channel_id',
+    type: 'text',
+    default: '',
+    editor: {
+      label: { en: 'Channel ID', ru: 'ID канала' },
+      required: true,
+    },
+  },
+  {
+    key: 'enabled',
+    type: 'boolean',
+    default: true,
+    editor: { label: { en: 'Enabled' } },
+  },
+]);
+
+const params = await api.config.getParams<{ channel_id: string; enabled: boolean }>();
+```
+
+### Outbound HTTP request
+
+Requires `NETWORK_REQUEST` permission in `manifest.json`:
+
+```typescript
+const response = await network.request.get('https://api.example.com/status');
+console.log(response.status, response.body);
+```
+
+### Dashboard events
+
+Requires `DASHBOARD_EVENTS` permission:
+
+```typescript
+dashboard.registerPlatform({ id: 'my_platform', name: { en: 'My Platform' } });
+
+dashboard.addRecord(
+  {
+    type: 'follow',
+    platform: 'my_platform',
+    message: { en: 'New follower!' },
+  },
+  { id: 'user_1', name: 'ViewerName' }
+);
+```
+
+### Addon-to-addon RPC
+
+Request data from another enabled addon:
+
+```typescript
+// In addon A
+addons.onRequest('getChannelId', () => ({ channelId: '12345' }));
+
+// In addon B
+const { channelId } = await addons.request<{ channelId: string }>(
+  'addon_a',
+  'getChannelId'
+);
+```
+
+---
+
+## `manifest.json` permissions
+
+Declared permissions must match sandbox API usage. Common values:
+
+| Permission | Used for |
+| --- | --- |
+| `WEB_END_POINTS` | `network.endpoints.create` |
+| `NETWORK_REQUEST` | `network.request.*` |
+| `NETWORK_WEBSOCKET` | `network.websocket.connect` |
+| `DASHBOARD_EVENTS` | `dashboard.addRecord`, `dashboard.registerTriggers` |
+| `DASHBOARD_CHAT` | `dashboard.addChatMessage`, chat badges |
+| `WEB_CONTENT` | Static web page served at `/addon_static/{id}/` |
+| `STATUS` | `status.Update`, `status.OnClick` |
+| `NOTIFY` | `notify.Send` |
+
+See the `AddonsPermission` union in the declaration file for the full list.
+
+---
+
+## What's included
+
+The published `addon.d.ts` is a `declare global` module:
+
+- Sandbox globals: `network`, `events`, `permissions`, `api`, `dashboard`, `addons`, `data`, `status`, `notify`, `game`, `storage`, `crypto`, timers, etc.
+- `GenerateConfig` and settings schema types
+- `AddonsPermission` enum-as-union
+- Supporting types (`DashboardLocalizedText`, config field types, …)
+
+Runtime behaviour (timeouts, host blocklists, permission gates) is enforced by StreamKit+ — typings describe the API surface only.
+
+---
+
+## Support
+
+This package tracks the StreamKit+ sandbox API. If typings are missing or outdated for your app version, install the matching `@rocketman-streamkit/types` release or report an issue to the StreamKit+ maintainers.

package/addon.d.ts

@@ -0,0 +1,1123 @@
+// AUTO-GENERATED — do not edit manually
+// Source: backend/addons/list/integrations/index.ts -> GenerateContext()
+
+declare global {
+  type URLSearchParamsInit = | string
+    | Record<string, string>
+    | Iterable<[string, string]>
+    | ReadonlyArray<[string, string]>
+    | URLSearchParams;
+
+  declare class URLSearchParams {
+    constructor(init?: URLSearchParamsInit);
+    static from(native: URLSearchParams): URLSearchParams;
+    append(name: string, value: string): void;
+    delete(name: string, value?: string): void;
+    get(name: string): string | null;
+    getAll(name: string): string[];
+    has(name: string, value?: string): boolean;
+    set(name: string, value: string): void;
+    sort(): void;
+    toString(): string;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+    entries(): IterableIterator<[string, string]>;
+    forEach(callback: (value: string, key: string, parent: URLSearchParams) => void, thisArg: unknown): void;
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+    size: number;
+  }
+
+  declare class UrlCustom {
+    constructor(url: string | UrlCustom, base?: string | UrlCustom);
+    static canParse(url: string, base?: string | UrlCustom): boolean;
+    static parse(url: string, base?: string | UrlCustom): UrlCustom | null;
+    toString(): string;
+    toJSON(): string;
+    href: string;
+    origin: string;
+    protocol: string;
+    username: string;
+    password: string;
+    host: string;
+    hostname: string;
+    port: string;
+    pathname: string;
+    search: string;
+    searchParams: URLSearchParams;
+    hash: string;
+  }
+
+  type AddonStatusState = 'offline' | 'connecting' | 'online' | 'error';
+
+  type LangData = string;
+
+  type AddonConfigLang = 'en' | 'ru' | 'uk';
+
+  /**
+   * Per-language text; `en` is required, other locales are optional.
+   */
+  type DashboardLocalizedText = { en: string } & Partial<
+    Record<Exclude<AddonConfigLang, 'en'>, string>
+  >;
+
+  type DashboardLocalizedString = | string
+    | [LangData, ...(string | number)[]]
+    | DashboardLocalizedText;
+
+  type DashboardChatEmote = {
+    /** Exact text token as it appears in chat (case-sensitive). */
+    word: string;
+    /** Image URL (ideally minimal size). */
+    url: string;
+  };
+
+  type DashboardChatMessageValue = {
+    id: string;
+    content: DashboardLocalizedString;
+    platform: string;
+    from?: string;
+    /**
+     * Emotes extracted from message payload (e.g. Twitch fragments).
+     * Used by the chat UI to render emote images even without registration.
+     */
+    emotes?: DashboardChatEmote[];
+  };
+
+  /**
+   * Payload delivered to addons subscribed via `dashboard.onChatMessage`.
+   */
+  type DashboardChatIncomingPayload = {
+    id: string;
+    created: number;
+    updated: number;
+    message: DashboardChatMessageValue;
+    user?: {
+      id: string;
+      name: string;
+      avatar: string;
+      platform: string;
+      color?: string;
+      icons?: string[];
+    };
+    sourceAddonId?: string;
+  };
+
+  type AddonConfigFieldType = | 'text'
+    | 'color'
+    | 'number'
+    | 'boolean'
+    | 'array'
+    | 'object'
+    | 'button'
+    | 'select'
+    | 'folder'
+    | 'file';
+
+  type AddonLocalizedString = Partial<Record<AddonConfigLang, string>>;
+
+  /**
+   * Options for folder/file picker fields in `GenerateConfig`.
+   */
+  type AddonConfigPathPicker = {
+    /** Native open-dialog title override. */
+    title?: AddonLocalizedString;
+    /**
+     * Electron dialog filters (`extensions` without a leading dot).
+     * Used by `file` fields only.
+     */
+    filters?: Array<{ name: string; extensions: string[] }>;
+    /**
+     * Require the selected file basename to match (case-insensitive on Windows).
+     * Example: `GTAV.exe`.
+     */
+    filename?: string;
+  };
+
+  type AddonConfigArrayItemType = 'text' | 'number';
+
+  type AddonConfigFieldValidation = {
+    required?: boolean;
+    pattern?: string;
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+  };
+
+  type AddonConfigFieldEditor = {
+    label?: AddonLocalizedString;
+    description?: AddonLocalizedString;
+    required?: boolean;
+    placeholder?: AddonLocalizedString;
+    validation?: AddonConfigFieldValidation;
+  };
+
+  type AddonConfigSelectOption = {
+    value: string;
+    label?: AddonLocalizedString;
+  };
+
+  type AddonConfigField = {
+    key: string;
+    type: AddonConfigFieldType;
+    default?: unknown;
+    editor?: AddonConfigFieldEditor;
+    /** Item type when `type` is `array`. */
+    items?: AddonConfigArrayItemType;
+    /** Select options when `type` is `select`. */
+    options?: AddonConfigSelectOption[];
+    /** Nested fields when `type` is `object`. */
+    fields?: AddonConfigField[];
+    /** Picker options when `type` is `folder` or `file`. */
+    pathPicker?: AddonConfigPathPicker;
+    /**
+     * Addon event name triggered when a `button` field is clicked in the
+     * settings UI. Must match the name passed to `events.On(name, ...)`.
+     * Required for `button` fields; ignored for all other types.
+     */
+    event?: string;
+  };
+
+  /**
+   * One settings field or a group of fields rendered on the same row in the UI.
+   */
+  type AddonConfigSchemaEntry = AddonConfigField | AddonConfigField[];
+
+  type AddonConfigSchema = AddonConfigSchemaEntry[];
+
+    /**
+     * The port of the local web server.
+     * @example const port = WEB_SERVER_PORT;
+    console.log(port);
+     */
+    var WEB_SERVER_PORT: number;
+    /**
+     * Check if developer mode is enabled
+    Can be used for additional logging and debugging, or advanced configuration.
+     * @example if (isDeveloperMode) {
+      console.log('Developer mode is enabled');
+    }
+     */
+    var isDeveloperMode: boolean;
+    /**
+     * Requires a module.
+     * @param name Module name.
+     * @returns Module.
+     * @example const fs = require('fs');
+    console.log(fs.readFileSync('package.json', 'utf8'));
+    Allows only with ROOT permission.
+     * @example const fs = require('fs');
+    console.log(fs.readFileSync('package.json', 'utf8'));
+    Allows only with ROOT permission.
+     * @example const fs = require('fs');
+    console.log(fs.readFileSync('package.json', 'utf8'));
+    Allows only with ROOT permission.
+     */
+    var require: (name: string) => any;
+    var URL: typeof UrlCustom;
+    var URLSearchParams: typeof URLSearchParams;
+    /**
+     * Private per-addon file storage in the addon install directory.
+    Persists a single JSON blob at `{data.path}/storage_data.json` across worker restarts.
+    Synchronous read/write in the integration worker — no IPC and no manifest permission required.
+     * @remarks - Not the same as {@link api.config.getParams } / {@link api.config.updateParams }: `storage` is
+      addon-internal runtime state (caches, counters, session maps) and is never shown in settings UI.
+    - {@link storage.Write } replaces the entire file; merge with a prior {@link storage.Read } when
+      updating part of the blob.
+    - Values must be JSON-serializable (objects, arrays, strings, numbers, booleans, `null`).
+    - The file is removed on uninstall; call {@link storage.Clear } to reset state without uninstalling.
+     * @example type CacheState = { lastSync: number; emoteIds: string[] };
+    const cached = storage.Read<CacheState>();
+    if (!cached) {
+      storage.Write<CacheState>({ lastSync: 0, emoteIds: [] });
+    }
+     * @example // Increment a counter persisted between restarts:
+    const count = storage.Read<{ n: number }>()?.n ?? 0;
+    storage.Write({ n: count + 1 });
+     */
+    var storage: {
+      /**
+       * Reads the persisted JSON blob for this addon.
+       * @template T Expected shape of the stored object (for TypeScript addons).
+       * @returns Parsed data cast to `T`, or `undefined` when `storage_data.json` does not exist yet.
+       * @example const state = storage.Read<{ offset: number }>();
+      const offset = state?.offset ?? 0;
+       * @example // First run — initialize defaults:
+      if (!storage.Read()) {
+        storage.Write({ seenIds: [] as string[] });
+      }
+       */
+      Read: <T>() => T | undefined;
+      /**
+       * Replaces the entire persisted JSON blob for this addon.
+       * @template T Shape of the object being stored.
+       * @param data JSON-serializable value written to `storage_data.json` (pretty-printed).
+       * @example storage.Write({ lastEventId: 'abc', processedAt: Date.now() });
+       * @example // Partial update — read, merge, write back:
+      const prev = storage.Read<{ tokens: string[] }>() ?? { tokens: [] };
+      storage.Write({ tokens: [...prev.tokens, newToken] });
+       */
+      Write: <T>(data: T) => void;
+      /**
+       * Deletes the persisted storage file for this addon.
+      No-op when `storage_data.json` is already missing.
+       * @example storage.Clear();
+      storage.Write({ fresh: true });
+       */
+      Clear: () => void;
+    };
+    /**
+     * Connection status shown in the main window status bar.
+     * @requires AddonsPermission.STATUS
+     * @example status.Update({ current: 'connecting', message: undefined });
+    status.OnClick(() => api.openUrl('https://twitch.tv'));
+    status.Update({
+      current: 'online',
+      message: { en: 'Twitch', ru: 'Twitch', uk: 'Twitch' },
+    });
+     */
+    var status: {
+      /**
+       * Current status payload mirrored to the main window.
+       */
+      data: {
+        current: AddonStatusState;
+        /**
+         * Tooltip text in the status bar (per-locale strings).
+         */
+        message: { en?: string | undefined; ru?: string | undefined; uk?: string | undefined; } | undefined;
+        /**
+         * Timestamp of the last status change.
+         */
+        timestamp: number | undefined;
+      };
+      /**
+       * Pushes status to the main window status bar.
+       * @requires AddonsPermission.STATUS
+       */
+      Update: (data: { current: AddonStatusState; message?: { en?: string | undefined; ru?: string | undefined; uk?: string | undefined; } | undefined; }) => void;
+      /**
+       * Registers a click handler for the status bar entry.
+       * @requires AddonsPermission.STATUS
+       */
+      OnClick: (handler: () => void) => void;
+    };
+    /**
+     * In-app notifications shown in the title-bar notification center.
+     * @requires AddonsPermission.NOTIFY
+     * @example notify.Send({
+      id: `${data.id}_status`,
+      type: 'success',
+      title: { en: 'Twitch' },
+      message: { en: 'Connected', ru: 'Подключено', uk: 'Підключено' },
+      temp: true,
+    });
+     */
+    var notify: {
+      /**
+       * Creates or replaces a notification record.
+      When `id` is provided, any previous record with the same id is removed first.
+       * @requires AddonsPermission.NOTIFY
+       */
+      Send: (payload: { id?: string | undefined; type?: "error" | "success" | "info" | "warning" | undefined; title?: DashboardLocalizedString | undefined; message: DashboardLocalizedString; temp?: boolean | undefined; }) => void;
+    };
+    /**
+     * Permission helpers for the running addon instance.
+    Values come from `manifest.json` and are fixed for the lifetime of the worker process.
+     * @example if (!permissions.has(AddonsPermission.NETWORK_REQUEST)) {
+      console.warn('Network is disabled for this addon');
+      return;
+    }
+     */
+    var permissions: {
+      /**
+       * Permissions granted to this addon (from manifest).
+      Treat as read-only; changing this array does not update the manifest or main process.
+       * @example console.log('Granted:', permissions.list.join(', '));
+       */
+      list: AddonsPermission[];
+      /**
+       * Returns whether the addon may use a capability.
+      Logs a warning to the worker console when access is denied.
+       * @param permission Capability to check (see global `AddonsPermission` enum in generated typings).
+       * @returns `true` if `permission` is listed or if `ROOT` is granted; otherwise `false`.
+       * @example if (permissions.has(AddonsPermission.CONFIG_WRITE)) {
+        await api.config.setConfig({ theme: 'dark' });
+      }
+       * @example // ROOT bypasses every individual check:
+      permissions.has(AddonsPermission.NETWORK_REQUEST); // true when list includes ROOT
+       */
+      has: (permission: AddonsPermission) => boolean;
+    };
+    /**
+     * In-addon event bus. Used mainly to handle HTTP endpoint callbacks registered via `network.endpoints.create`.
+    Handlers run in the integration worker when the main process forwards `customEvent` messages.
+     * @example events.On('onDonation', payload => {
+      console.log('Donation', payload.body);
+      return { ok: true };
+    });
+     */
+    var events: {
+      /**
+       * Internal registry of active handlers. Prefer `events.On` / subscription `Destroy` for lifecycle control.
+       */
+      list: { id: string; name: string; handle: (data: any) => any; }[];
+      /**
+       * Registers a named handler. The name must match `callbackName` passed to `network.endpoints.create`.
+       * @param name Event identifier (callback name).
+       * @param handler Receives `{ query, params, body }` from Express for HTTP endpoints; return value is sent as the HTTP response body.
+       * @returns Subscription with `id` and `Destroy()` to unregister.
+       * @example network.endpoints.create('/hook', 'POST', 'onHook');
+      const sub = events.On('onHook', ({ body }) => {
+        console.log(body);
+        return 'received';
+      });
+      // later: sub.Destroy();
+       */
+      On: (name: string, handler: (data: any) => any) => { id: string; Destroy(): void; };
+    };
+    /**
+     * Outbound HTTP and inbound HTTP endpoint helpers (worker-side).
+    Outbound calls are subject to DNS/IP filtering, concurrency limits, and permission checks.
+     */
+    var network: {
+      /**
+       * Registers HTTP routes on the main-process web server under `/addon/{addonId}/...`.
+       */
+      endpoints: {
+        /**
+         * Creates a route and binds it to an `events.On` handler by name.
+         * @requires AddonsPermission.WEB_END_POINTS
+         * @param path Suffix appended after `/addon/{id}/` (leading slash optional).
+         * @param type HTTP method exposed by the backend server.
+         * @param callbackName Must match the first argument of `events.On`.
+         * @returns Promise resolving to `{ success: true }` or `{ success: false, message: string }`.
+         * @example await network.endpoints.create('alerts', 'POST', 'handleAlert');
+        events.On('handleAlert', ({ body }) => ({ received: body }));
+        // POST http://localhost:{WEB_SERVER_PORT}/addon/twitch/alerts
+         */
+        create: (path: string, type: "GET" | "POST", callbackName: string) => Promise<unknown>;
+      };
+      /**
+       * Registers Socket.IO namespaces on the main-process web server.
+      Clients connect with path `/addon/socket.io` and namespace `/addon/{addonId}/{path}`.
+       */
+      socketEndpoints: {
+        /**
+         * Creates a Socket.IO namespace and binds lifecycle/events to an `events.On` handler.
+         * @requires AddonsPermission.SOCKET_END_POINTS
+         * @param path Suffix appended after `/addon/{id}/` (leading slash optional).
+         * @param callbackName Must match the first argument of `events.On`.
+         * @returns Promise resolving to `{ success: true }` or `{ success: false, message: string }`.
+         * @remarks Handler receives `{ type: 'connect' | 'disconnect' | 'event', socketId, ... }`.
+        For `type: 'event'`, a non-undefined return value is emitted back to the client as `reply`.
+         * @example await network.socketEndpoints.create('live', 'onSocket');
+        events.On('onSocket', payload => {
+          if (payload.type === 'event' && payload.event === 'ping') {
+            return { pong: true };
+          }
+        });
+        // Client: io('http://localhost:3000/addon/mywidget/live', { path: '/addon/socket.io' })
+         */
+        create: (path: string, callbackName: string) => Promise<unknown>;
+        /**
+         * Emits an event to connected Socket.IO clients on a registered namespace.
+         * @requires AddonsPermission.SOCKET_END_POINTS
+         * @param path Namespace suffix passed to `create` (e.g. `'live'`).
+         * @param event Event name clients listen for.
+         * @param data JSON-serializable payload.
+         * @param socketId Optional socket id — omit to broadcast to all clients.
+         * @returns `{ success: true }` or `{ success: false, message: string }`.
+         * @example await network.socketEndpoints.emit('live', 'chat:message', { text: 'Hello' });
+         */
+        emit: (path: string, event: string, data: unknown, socketId: string | undefined) => Promise<unknown>;
+      };
+      /**
+       * Outbound HTTP client (worker process). Responses are always plain text (`response.text()`).
+       * @remarks Max 5 concurrent requests; 10s timeout; redirects are not followed; private/local networks are blocked.
+       */
+      request: {
+        /**
+         * Performs a GET request.
+         * @requires AddonsPermission.NETWORK_REQUEST
+         * @param url Absolute URL (http/https). Blocked if host resolves to loopback or RFC1918 ranges.
+         * @param headers Optional request headers.
+         * @returns Response body as string.
+         * @example const html = await network.request.get('https://api.example.com/status');
+         */
+        get: (url: string, headers?: Record<string, string>) => Promise<string>;
+        /**
+         * Performs a POST request with JSON body (`Content-Type: application/json`).
+         * @requires AddonsPermission.NETWORK_REQUEST
+         * @param url Target URL.
+         * @param body Serializable object; sent as `JSON.stringify(body)`.
+         * @param headers Extra headers merged with the default content type.
+         * @returns Response body as string.
+         * @example const res = await network.request.post('https://api.example.com/hook', { live: true });
+         */
+        post: (url: string, body: any, headers?: Record<string, string>) => Promise<string>;
+        /**
+         * Performs a PUT request with JSON body.
+         * @requires AddonsPermission.NETWORK_REQUEST
+         * @param url Target URL.
+         * @param body Request payload object.
+         * @param headers Optional extra headers.
+         * @returns Response body as string.
+         */
+        put: (url: string, body: any, headers?: Record<string, string>) => Promise<string>;
+        /**
+         * Performs a DELETE request.
+         * @requires AddonsPermission.NETWORK_REQUEST
+         * @param url Target URL.
+         * @param headers Optional request headers.
+         * @returns Response body as string.
+         */
+        delete: (url: string, headers?: Record<string, string>) => Promise<string>;
+        /**
+         * Performs a POST request with `application/x-www-form-urlencoded` body.
+         * @requires AddonsPermission.NETWORK_REQUEST
+         * @param url Target URL.
+         * @param fields Form fields encoded as URLSearchParams.
+         * @param headers Optional extra headers.
+         * @returns Response body as string.
+         */
+        postForm: (url: string, fields: Record<string, string>, headers?: Record<string, string>) => Promise<string>;
+      };
+      /**
+       * Outbound WebSocket client (worker process).
+       * @remarks Max 5 concurrent connections; private/local networks are blocked.
+       */
+      websocket: {
+        /**
+         * Opens a WebSocket connection to an external host.
+         * @requires AddonsPermission.NETWORK_WEBSOCKET
+         * @param url Absolute `ws://` or `wss://` URL. Blocked if host resolves to loopback or RFC1918 ranges.
+         * @param options Optional subprotocols and handshake headers.
+         * @returns Connection handle with event subscriptions and `Send` / `Close` / `Destroy`.
+         * @example const ws = await network.websocket.connect('wss://example.com/socket', {
+          headers: { Authorization: 'Bearer token' },
+        });
+        ws.On('open', () => ws.Send({ type: 'ping' }));
+        ws.On('message', data => console.log(data));
+        ws.On('close', ({ code, reason }) => console.log(code, reason));
+         */
+        connect: (url: string, options?: { headers?: Record<string, string> | undefined; protocols?: string | string[] | undefined; }) => Promise<{ readonly state: 0 | 1 | 2 | 3; On(event: "error" | "open" | "message" | "close", handler: (() => void) | ((data: string) => void) | ((data: { code: number; reason: string; }) => void) | ((error: Error) => void)): { id: string; Destroy(): void; }; Send(data: string | number | boolean | Record<string, unknown>): void; Close(code?: number, reason?: string): void; Destroy(): void; }>;
+      };
+    };
+    /**
+     * Metadata for the integration instance loaded into this worker.
+    Populated from main process before `vm.runInContext` executes addon code.
+     * @example console.log(`Running addon: ${data.id}`);
+    console.log(`Frontend token: ${data.token}`);
+    events.On('onParams', ({ query }) => {
+      if (query.token !== data.token) {
+        return { success: false, message: 'Unauthorized' };
+      }
+      return api.config.getParams();
+    });
+     */
+    var data: {
+      id: string;
+      permissions: AddonsPermission[];
+      /**
+       * Recorded addon install folder path (used for frontend access token derivation).
+       */
+      path: string;
+      /**
+       * Stable frontend access token for this addon instance (`?token=` on web pages).
+       */
+      token: string;
+    };
+    /**
+     * Logging helpers prefixed with `[Addon {id}]` for easier filtering in worker logs.
+     */
+    var console: {
+      /**
+       * Writes an informational log line.
+       */
+      log: (...args: any[]) => void;
+      /**
+       * Writes an error log line.
+       */
+      error: (...args: any[]) => void;
+      /**
+       * Writes a warning log line.
+       */
+      warn: (...args: any[]) => void;
+      /**
+       * Writes an info log line.
+       */
+      info: (...args: any[]) => void;
+    };
+    /**
+     * Schedules a one-shot callback. Errors inside `fn` are caught and logged; they do not crash the worker.
+     * @param fn Callback executed after the delay.
+     * @param delay Milliseconds to wait (clamped to max 60_000).
+     * @param args Optional arguments forwarded to `fn`.
+     * @returns Timer handle compatible with `clearTimeout`.
+     * @example setTimeout(() => console.log('ready'), 500);
+     */
+    var setTimeout: (fn: any, delay?: number, ...args: any[]) => number;
+    /**
+     * Cancels a timer created by `setTimeout`.
+     * @param id Handle returned from `setTimeout`.
+     */
+    var clearTimeout: (id: any) => void;
+    /**
+     * Schedules a repeating callback. Interval is clamped between 50 ms and 60_000 ms.
+     * @param fn Callback invoked on each tick.
+     * @param interval Period in milliseconds (default 1000).
+     * @param args Optional arguments forwarded to `fn`.
+     * @returns Timer handle compatible with `clearInterval`.
+     */
+    var setInterval: (fn: any, interval?: number, ...args: any[]) => number;
+    /**
+     * Cancels a timer created by `setInterval`.
+     * @param id Handle returned from `setInterval`.
+     */
+    var clearInterval: (id: any) => void;
+    /**
+     * Resolves after a delay (max 60_000 ms). Useful for simple polling/backoff in addon code.
+     * @param ms Milliseconds to wait.
+     * @returns Promise that resolves with no value.
+     * @example await sleep(1000);
+     */
+    var sleep: (ms: number) => Promise<unknown>;
+    /**
+     * Non-cryptographic random helpers for IDs and UI sampling inside addons.
+     */
+    var random: {
+      /**
+       * Inclusive integer in `[min, max]`.
+       * @param min Lower bound (default 0).
+       * @param max Upper bound (default 1).
+       * @example const dice = random.number(1, 6);
+       */
+      number: (min?: number, max?: number) => number;
+      /**
+       * Short alphanumeric string suitable for correlation IDs (not UUID-strength).
+       * @example const eventId = random.id();
+       */
+      id: () => string;
+    };
+    /**
+     * Cryptographic helpers executed in the worker (not inside addon VM imports).
+     */
+    var crypto: {
+      /**
+       * Creates a PKCE verifier/challenge pair for OAuth 2.1 (S256).
+       */
+      createPkce: () => { verifier: string; challenge: string; };
+      /**
+       * Verifies an RSA-SHA256 PKCS#1 v1.5 signature (e.g. Kick webhooks).
+       */
+      verifyRsaSha256: (publicKeyPem: string, message: string, signatureBase64: string) => boolean;
+    };
+    /**
+     * RPC-style access to main-process services (config, persistence).
+    All methods are async and cross the worker IPC boundary.
+     */
+    var api: {
+      /**
+       * Opens a URL in the default browser
+       * @param url URL to open
+       * @example api.openUrl('https://www.google.com');
+       */
+      openUrl: (url: string) => void;
+      /**
+       * Fully restarts this addon worker process.
+       */
+      restart: () => void;
+      /**
+       * Application and per-addon configuration stored in the main process.
+       */
+      config: {
+        /**
+         * Reads persisted settings for this addon (`Config.data.addonsParams[id]`).
+         * @returns Stored parameter object (empty object if none saved yet).
+         * @example const params = await api.config.getParams<{ token: string }>();
+        console.log(params.token);
+         */
+        getParams: <T extends Record<string, any>>() => Promise<T>;
+        /**
+         * Replaces this addon's parameter blob in app config.
+        Size limit: 10_000 bytes JSON unless `INCREASE_CONFIG_SIZE` is granted (then 1_000_000).
+         * @param data New parameters object.
+         * @returns `{ success: true, params }` or `{ success: false, message }`.
+         * @example await api.config.updateParams({ lastSync: Date.now() });
+         */
+        updateParams: <T extends Record<string, any>>(data: T) => Promise<unknown>;
+        /**
+         * Reads the full application config from the main process.
+         * @requires AddonsPermission.CONFIG_READ
+         * @returns Full config object, or `null` when permission is missing.
+         * @example const cfg = await api.config.getConfig();
+         */
+        getConfig: <T extends Record<string, any>>() => Promise<T>;
+        /**
+         * Patches global application config via `Config.Update`.
+         * @requires AddonsPermission.CONFIG_WRITE
+         * @param data Partial config fields accepted by main-process storage.
+         * @returns `{ success: true }` or `{ success: false, message }`.
+         */
+        setConfig: <T extends Record<string, any>>(data: T) => Promise<unknown>;
+        /**
+         * Reads persisted settings of another installed addon.
+         * @requires AddonsPermission.ADDON_CONFIG_READ
+         * @param addonId Target addon identifier.
+         * @returns `{ success, params }` or `{ success: false, message }`.
+         * @example const twitch = await api.config.getAddonParams<{ access_token?: string }>('twitch');
+         */
+        getAddonParams: <T extends Record<string, any>>(addonId: string) => Promise<{ success: true; params: T; } | { success: false; message: string; }>;
+      };
+    };
+    /**
+     * Addon-to-addon request/response API (separate from `events`).
+    Use {@link addons.request } to call another addon and {@link addons.onRequest }
+    to expose handlers in the current addon.
+     */
+    var addons: {
+      /**
+       * Sends a request to another enabled addon and waits for its response.
+       * @param targetAddonId Receiver addon id.
+       * @param method Handler method name registered via `addons.onRequest`.
+       * @param params Optional payload for the receiver.
+       * @returns Receiver response or an error when routing fails.
+       * @example const channel = await addons.request('twitch', 'getChannelId');
+       */
+      request: (targetAddonId: string, method: string, params: unknown) => Promise<{ success: true; result?: unknown; } | { success: false; message?: string | undefined; }>;
+      /**
+       * Registers a request handler exposed to other addons.
+      The handler receives the sender addon id and request params.
+       * @param method Unique method name within this addon.
+       * @param handler Async callback that returns the response payload.
+       * @example addons.onRequest('getChannelId', async ({ fromAddonId }) => {
+        console.log('Request from', fromAddonId);
+        return { channelId: '123' };
+      });
+       */
+      onRequest: (method: string, handler: (payload: { fromAddonId: string; params?: unknown; }) => unknown) => void;
+      /**
+       * Removes a previously registered addon request handler.
+       * @param method Handler method name passed to `addons.onRequest`.
+       */
+      offRequest: (method: string) => void;
+    };
+    /**
+     * Built-in UI helpers for addon web flows (OAuth callbacks, etc.).
+     */
+    var ui: {
+      /**
+       * OAuth authorization result pages served by the local web server.
+      Return `{ redirect: ui.auth.generateSuccess() }` from an endpoint handler
+      to send the user to the styled success page.
+       */
+      auth: {
+        /**
+         * Builds a redirect URL for the OAuth success page.
+         * @param message Optional custom message shown via `?message=`.
+         * @returns Absolute URL on the local web server.
+         * @example return { redirect: ui.auth.generateSuccess('Twitch connected') };
+         */
+        generateSuccess: (message: string | undefined) => string;
+        /**
+         * Builds a redirect URL for the OAuth failure page.
+         * @param message Optional custom message shown via `?message=`.
+         * @returns Absolute URL on the local web server.
+         * @example return { redirect: ui.auth.generateFail('Invalid OAuth state') };
+         */
+        generateFail: (message: string | undefined) => string;
+      };
+    };
+    /**
+     * Dashboard feed: latest events widget and chat window.
+    User profiles are shared via `upsertUser` and referenced by `from` on records/messages.
+     */
+    var dashboard: {
+      /**
+       * Registers a platform identifier for dashboard events and chat.
+      The `id` must match the `platform` field on records and messages.
+      Icon is taken from the addon manifest when present.
+      Re-registering the same id from the same addon is allowed.
+       * @requires AddonsPermission.DASHBOARD_EVENTS or AddonsPermission.DASHBOARD_CHAT
+       * @example await dashboard.registerPlatform({
+        id: 'twitch',
+        name: { en: 'Twitch', ru: 'Twitch', uk: 'Twitch' },
+      });
+       */
+      registerPlatform: (platform: { id: string; name: Partial<Record<"en" | "ru" | "uk", string>>; }) => Promise<unknown>;
+      /**
+       * Registers chat badge images so the chat UI can resolve
+      `DashboardRecordUserValue.icons` identifiers to image URLs.
+      
+      Re-registering badges is allowed and updates the mapping on the fly.
+       * @requires AddonsPermission.DASHBOARD_EVENTS or AddonsPermission.DASHBOARD_CHAT
+       */
+      registerChatBadges: (badges: { id: string; url: string; title?: string | undefined; }[]) => Promise<unknown>;
+      /**
+       * Returns chat badge images registered by platform addons (id → url/title).
+       * @requires AddonsPermission.DASHBOARD_CHAT or AddonsPermission.DASHBOARD_CHAT_INCOMING
+       */
+      listChatBadges: () => Promise<unknown>;
+      /**
+       * Returns chat emotes registered by platform addons (platform → word → url).
+       * @requires AddonsPermission.DASHBOARD_CHAT or AddonsPermission.DASHBOARD_CHAT_INCOMING
+       */
+      listChatEmotes: () => Promise<unknown>;
+      /**
+       * Returns streaming platforms registered by addons (id, name, iconUrl).
+       * @requires AddonsPermission.DASHBOARD_CHAT or AddonsPermission.DASHBOARD_CHAT_INCOMING
+       */
+      listPlatforms: () => Promise<unknown>;
+      /**
+       * Registers emote images so the chat UI can replace tokens in messages.
+      
+      Several addons may register emotes for the same platform; re-registering
+      is allowed and updates mapping on the fly.
+       * @requires AddonsPermission.DASHBOARD_EVENTS or AddonsPermission.DASHBOARD_CHAT
+       */
+      registerChatEmotes: (payload: { platforms: string[]; emotes: { word: string; url: string; }[]; }) => Promise<unknown>;
+      /**
+       * Creates or updates a user shown in chat and event rows.
+       * @requires AddonsPermission.DASHBOARD_EVENTS or AddonsPermission.DASHBOARD_CHAT
+       */
+      upsertUser: (user: { id: string; name: string; avatar?: string | undefined; platform: string; color?: string | undefined; icons?: string[] | undefined; }) => Promise<unknown>;
+      /**
+       * Registers overlay trigger options shown in overlay addon settings.
+      
+      Call once at addon load (before or after auth). Each entry describes one
+      event type the user can bind to an overlay in **Settings → Overlay → Triggers**.
+      When your addon pushes a dashboard event, pass a matching `{ trigger }` in
+      `dashboard.addRecord(..., user, { trigger })` so the overlay matcher can
+      find configured rules (`addonId` + `type` + optional `key` + `value`).
+       * @requires AddonsPermission.DASHBOARD_EVENTS
+       * @param options Array of trigger option descriptors (see fields below).
+      
+      **Option fields**
+      
+      | Field | Description |
+      | --- | --- |
+      | `type` | Event kind: `donation`, `subscribe`, `subgift`, `follow`, or `custom`. Must match `trigger.type` you pass to `addRecord`. |
+      | `key` | Fixed discriminator when one `type` has several variants. Examples: `bits`, `kicks`, `redeems`. Stored in saved trigger `key` and compared to `trigger.key` on incoming events. Do **not** set when using `keyOptions` (user picks the key in settings). |
+      | `label` | Localized name shown in the event dropdown (`en` required; `ru`, `uk` optional). |
+      | `valueType` | How the value field is rendered: `text`, `number`, `select`, or `dynamic`. Omit for triggers without a value (e.g. `follow`). |
+      | `valueOptions` | For `valueType: 'select'`. `{ value, label }[]` — `value` is matched against incoming events; `label` is shown in UI. |
+      | `valueProvider` | For `valueType: 'dynamic'`. Provider id; handle `overlayTriggerValue:{provider}:list\|create\|release` events in this addon. |
+      | `valueGenerateLabel` | For `dynamic`: label of the “generate new value” option in the dropdown. |
+      | `requireValue` | Extra input before `create` (e.g. reward cost). Sent as `context[key]` on create. Fields: `key`, `type`, `label`, `default`, `min`. |
+      | `valueHint` | Label/hint for `text` / `number` value fields (e.g. “Donation amount”). |
+      | `keyOptions` | User-selectable keys (e.g. currency codes). Renders a second dropdown; chosen value is stored in saved trigger `key`. |
+      | `keyLabel` | Label for the `keyOptions` dropdown (e.g. “Currency”). |
+      | `valueMatch` | Numeric matching mode. Default: `exact` (incoming === configured). Use `minimum` for “at or above” thresholds (bits, KICKs, sub gift count). |
+      
+      **Matching rules**
+      
+      - Saved overlay rule: `{ targetId, addonId, type, key?, value }`.
+      - Incoming event: `{ type, key?, value? }` from `addRecord` options.
+      - `addonId` and `type` must match; `key` must match when both sides have it.
+      - `value`: compared per `valueMatch` for numbers; strings use strict equality.
+      
+      **Dynamic provider contract**
+      
+      - `overlayTriggerValue:{provider}:list` → `{ success, items?: [{ id, label, meta? }] }`
+      - `overlayTriggerValue:{provider}:create` → `{ success, valueId?, label?, meta? }`
+      (payload includes `title`, `overlayId`, `context` from `requireValue`)
+      - `overlayTriggerValue:{provider}:release` → `{ success }` (payload: `valueId`;
+      called on settings save when the value is no longer referenced)
+       * @example // Follow — no value field
+      await dashboard.registerTriggers([
+        { type: 'follow', label: { en: 'New follower', ru: 'Новый фолловер' } },
+      ]);
+       * @example // Custom numeric trigger with minimum threshold (bits)
+      await dashboard.registerTriggers([
+        {
+          type: 'custom',
+          key: 'bits',
+          label: { en: 'Cheer (bits)', ru: 'Cheer (битсы)' },
+          valueType: 'number',
+          valueMatch: 'minimum',
+          valueHint: { en: 'Minimum bits', ru: 'Минимум битсов' },
+        },
+      ]);
+      // Fire: { trigger: { type: 'custom', key: 'bits', value: 100 } }
+      // Matches configured value 100 when viewer cheers 100+ bits.
+       * @example // Donation with currency picker and exact amount (default valueMatch)
+      await dashboard.registerTriggers([
+        {
+          type: 'donation',
+          label: { en: 'Donation', ru: 'Донат' },
+          valueType: 'number',
+          keyOptions: [
+            { value: 'RUB', label: { en: 'RUB' } },
+            { value: 'USD', label: { en: 'USD' } },
+          ],
+          keyLabel: { en: 'Currency', ru: 'Валюта' },
+          valueHint: { en: 'Donation amount', ru: 'Сумма доната' },
+        },
+      ]);
+      // Fire: { trigger: { type: 'donation', key: 'RUB', value: 500 } }
+       * @example // Select: separate UI label and match value (sub tier)
+      await dashboard.registerTriggers([
+        {
+          type: 'subscribe',
+          label: { en: 'Subscription', ru: 'Подписка' },
+          valueType: 'select',
+          valueOptions: [
+            { value: '1000', label: { en: 'Tier 1', ru: 'Тир 1' } },
+            { value: '2000', label: { en: 'Tier 2', ru: 'Тир 2' } },
+          ],
+        },
+      ]);
+       * @example // Dynamic: list / generate / release via events.On in this addon
+      await dashboard.registerTriggers([
+        {
+          type: 'custom',
+          key: 'redeems',
+          label: { en: 'Channel point reward', ru: 'Награда за баллы' },
+          valueType: 'dynamic',
+          valueProvider: 'rewards',
+          valueGenerateLabel: { en: 'Generate reward', ru: 'Сгенерировать' },
+          requireValue: {
+            key: 'cost',
+            type: 'number',
+            label: { en: 'Reward cost', ru: 'Стоимость' },
+            default: 100,
+            min: 1,
+          },
+        },
+      ]);
+      events.On('overlayTriggerValue:rewards:list', async () => ({
+        success: true,
+        items: [{ id: 'abc', label: 'My reward', meta: '100' }],
+      }));
+       * @example // Pass matching trigger when pushing dashboard events
+      await dashboard.addRecord(
+        { id: random.id(), type: 'custom', platform: 'twitch', message: '100 bits!' },
+        user,
+        { trigger: { type: 'custom', key: 'bits', value: 100 } },
+      );
+       */
+      registerTriggers: (options: { type: "donation" | "subscribe" | "subgift" | "follow" | "custom"; key?: string | undefined; label?: Partial<Record<"en" | "ru" | "uk", string>> | undefined; valueType?: "number" | "text" | "select" | "dynamic" | undefined; valueOptions?: { value: string | number; label: Partial<Record<"en" | "ru" | "uk", string>>; }[] | undefined; valueProvider?: string | undefined; valueGenerateLabel?: Partial<Record<"en" | "ru" | "uk", string>> | undefined; requireValue?: { key?: string | undefined; type?: "number" | "text" | undefined; label?: Partial<Record<"en" | "ru" | "uk", string>> | undefined; default?: string | number | undefined; min?: number | undefined; } | undefined; valueHint?: Partial<Record<"en" | "ru" | "uk", string>> | undefined; keyOptions?: { value: string | number; label: Partial<Record<"en" | "ru" | "uk", string>>; }[] | undefined; keyLabel?: Partial<Record<"en" | "ru" | "uk", string>> | undefined; valueMatch?: "exact" | "minimum" | undefined; }[]) => Promise<unknown>;
+      /**
+       * Pushes an event into the latest-events widget.
+       * @requires AddonsPermission.DASHBOARD_EVENTS
+      `message` accepts a plain string, a `[LangData, ...args]` tuple (app
+      translation key with placeholders), or `{ en, ru?, uk? }` per-language
+      text (`en` required; missing locale falls back to `en` in the UI).
+      Optional `trigger` is used by the overlay system to match configured rules.
+       * @example await dashboard.addRecord({
+        id: random.id(),
+        type: 'donation',
+        platform: 'twitch',
+        amount: [5, 'USD'],
+        message: { en: 'Thanks!', ru: 'Спасибо!' },
+        from: 'user-1',
+      }, { id: 'user-1', name: 'Viewer', avatar: '', platform: 'twitch', color: '#7fff00' }, {
+        trigger: { type: 'donation', key: 'USD', value: 5 },
+      });
+       */
+      addRecord: (record: { id?: string | undefined; type: "donation" | "subscribe" | "follow" | "custom" | "timer"; amount?: [number, string] | undefined; platform: string; message?: DashboardLocalizedString | undefined; from?: string | undefined; attach?: { type: string; value: string; }[] | undefined; }, user: { id: string; name: string; avatar?: string | undefined; platform: string; color?: string | undefined; icons?: string[] | undefined; } | undefined, options: { trigger?: { type: "donation" | "subscribe" | "subgift" | "follow" | "custom"; key?: string | undefined; value?: string | number | boolean | undefined; } | undefined; triggers?: { type: "donation" | "subscribe" | "subgift" | "follow" | "custom"; key?: string | undefined; value?: string | number | boolean | undefined; }[] | undefined; } | undefined) => Promise<unknown>;
+      /**
+       * Pushes a chat line into the chat dashboard window.
+      `content` accepts the same formats as `addRecord` `message`: plain
+      string, `[LangData, ...args]` tuple, or `{ en, ru?, uk? }` object.
+       * @requires AddonsPermission.DASHBOARD_CHAT
+       */
+      addChatMessage: (message: { id?: string | undefined; content: DashboardLocalizedString; platform: string; from?: string | undefined; emotes?: { word: string; url: string; }[] | undefined; }, user: { id: string; name: string; avatar?: string | undefined; platform: string; color?: string | undefined; icons?: string[] | undefined; } | undefined) => Promise<unknown>;
+      /**
+       * Subscribes to outgoing messages from the chat window input.
+      The handler receives `{ text }` when the user sends a message and this
+      addon is selected as a target.
+       * @requires AddonsPermission.DASHBOARD_CHAT
+       * @example dashboard.onChatSend(async ({ text }) => {
+        console.log('User sent:', text);
+      });
+       */
+      onChatSend: (handler: (payload: { text: string; }) => void | Promise<void>) => Promise<unknown>;
+      /**
+       * Unsubscribes from outgoing chat window messages.
+       * @requires AddonsPermission.DASHBOARD_CHAT
+       */
+      offChatSend: () => Promise<unknown>;
+      /**
+       * Subscribes to new chat messages shown in the chat dashboard window.
+      The handler receives a detailed payload with message metadata, author info,
+      and the addon id that pushed the message (if any).
+       * @requires AddonsPermission.DASHBOARD_CHAT_INCOMING
+       * @example dashboard.onChatMessage(msg => {
+        console.log(msg.message.content, msg.user?.name, msg.sourceAddonId);
+      });
+       */
+      onChatMessage: (handler: (payload: DashboardChatIncomingPayload) => void | Promise<void>) => Promise<unknown>;
+      /**
+       * Unsubscribes from incoming chat dashboard messages.
+       * @requires AddonsPermission.DASHBOARD_CHAT_INCOMING
+       */
+      offChatMessage: () => Promise<unknown>;
+    };
+    /**
+     * Game integration API for `manifest.type: "game"` addons.
+    Register in-game actions the user can bind to dashboard events in
+    **Settings → Game integrations**.
+     */
+    var game: {
+      /**
+       * Registers input triggers (in-game actions) for this game addon.
+      Call once at addon load. The user binds dashboard events to each action
+      in the addon settings UI. Handle invocations with
+      `events.On('gameInputTrigger', payload => { ... })`.
+      
+      Game addons may also call `dashboard.registerTriggers()` (requires
+      `DASHBOARD_EVENTS`) so overlays and other modules can react to game events.
+       * @param options Registered actions (`id` must be unique within this addon).
+       * @example await game.registerInputTriggers([
+        { id: 'spawn_car', label: { en: 'Spawn car', ru: 'Заспавнить машину' } },
+        { id: 'explosion', label: { en: 'Explosion', ru: 'Взрыв' } },
+      ]);
+      events.On('gameInputTrigger', ({ actionId, trigger, record, user }) => {
+        if (actionId === 'spawn_car') { ... }
+      });
+       */
+      registerInputTriggers: (options: { id: string; label?: Partial<Record<"en" | "ru" | "uk", string>> | undefined; description?: Partial<Record<"en" | "ru" | "uk", string>> | undefined; }[]) => Promise<unknown>;
+    };
+    /**
+     * Declares addon settings schema for the settings UI and initializes default params.
+    Fields without `editor` are stored but not shown in the settings form.
+    A `button` field stores no value: it renders a button in the settings UI and,
+    when clicked, triggers the addon event named by its `event` property
+    (handle it with `events.On(event, ...)`).
+     * @param schema Declarative list of config keys, types, defaults, and optional editor metadata.
+    Nested arrays place multiple fields on one settings row.
+     * @returns Main-process response `{ success, params?, message? }`.
+     * @example GenerateConfig([
+      {
+        key: 'theme',
+        type: 'select',
+        default: 'dark',
+        options: [
+          { value: 'dark', label: { en: 'Dark', ru: 'Тёмная', uk: 'Темна' } },
+          { value: 'light', label: { en: 'Light', ru: 'Светлая', uk: 'Світла' } },
+        ],
+        editor: { label: { en: 'Theme', ru: 'Тема', uk: 'Тема' } },
+      },
+      [
+        {
+          key: 'width',
+          type: 'number',
+          default: 1920,
+          editor: { label: { en: 'Width', ru: 'Ширина', uk: 'Ширина' } },
+        },
+        {
+          key: 'height',
+          type: 'number',
+          default: 1080,
+          editor: { label: { en: 'Height', ru: 'Высота', uk: 'Висота' } },
+        },
+      ],
+      {
+        key: 'oauth',
+        type: 'text',
+        default: '',
+        editor: {
+          label: { en: 'OAuth token', ru: 'OAuth токен', uk: 'OAuth токен' },
+          required: true,
+          validation: { pattern: '^[a-zA-Z0-9]+$' },
+        },
+      },
+      { key: 'last_update', type: 'number', default: 0 },
+      {
+        key: 'reconnect',
+        type: 'button',
+        event: 'onReconnect',
+        editor: { label: { en: 'Reconnect', ru: 'Переподключиться' } },
+      },
+      {
+        key: 'game_dir',
+        type: 'folder',
+        default: '',
+        pathPicker: { title: { en: 'Game folder', ru: 'Папка с игрой' } },
+        editor: { label: { en: 'Install folder', ru: 'Папка установки' } },
+      },
+      {
+        key: 'game_exe',
+        type: 'file',
+        default: '',
+        pathPicker: {
+          title: { en: 'Game executable', ru: 'Исполняемый файл игры' },
+          filename: 'GTAV.exe',
+          filters: [{ name: 'Executable', extensions: ['exe'] }],
+        },
+        editor: { label: { en: 'GTA V executable', ru: 'Файл GTAV.exe' }, required: true },
+      },
+    ]);
+    // events.On('onReconnect', () => { ... });
+     */
+    var GenerateConfig: (schema: AddonConfigSchema) => Promise<unknown>;
+
+  /**
+   * Addons permissions
+   */
+  type AddonsPermission =
+  /**
+   * Global access for all features
+   */
+    | 'ROOT'
+  /**
+   * Access to the storage module with a limit of 1MB
+   */
+    | 'INCREASE_CONFIG_SIZE'
+  /**
+   * Read full config file
+   */
+    | 'CONFIG_READ'
+  /**
+   * Read configuration parameters of other addons
+   */
+    | 'ADDON_CONFIG_READ'
+  /**
+   * Write full config file
+   */
+    | 'CONFIG_WRITE'
+  /**
+   * Perform network requests (GET, POST, PUT, DELETE)
+   */
+    | 'NETWORK_REQUEST'
+  /**
+   * Open outbound WebSocket connections
+   */
+    | 'NETWORK_WEBSOCKET'
+  /**
+   * Ability to create web endpoints
+   */
+    | 'WEB_END_POINTS'
+  /**
+   * Serve manifest-declared web page and static files for overlay
+   */
+    | 'WEB_CONTENT'
+  /**
+   * Display connection status in the main window status bar
+   */
+    | 'STATUS'
+  /**
+   * Push in-app notifications to the title-bar notification center
+   */
+    | 'NOTIFY'
+  /**
+   * Push events to the latest-events dashboard widget
+   */
+    | 'DASHBOARD_EVENTS'
+  /**
+   * Push messages to the chat dashboard window
+   */
+    | 'DASHBOARD_CHAT'
+  /**
+   * Receive new chat messages from the chat dashboard window
+   */
+    | 'DASHBOARD_CHAT_INCOMING'
+  /**
+   * Create Socket.IO namespaces for addon web pages and external clients
+   */
+    | 'SOCKET_END_POINTS';
+}
+
+export {};

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@rocketman-streamkit/types",
+  "version": "1.0.0",
+  "description": "TypeScript declarations for the StreamKit+ integration addon sandbox API",
+  "types": "addon.d.ts",
+  "files": [
+    "addon.d.ts",
+    "README.md"
+  ],
+  "keywords": [
+    "streamkit",
+    "streamkitplus",
+    "addon",
+    "integration",
+    "typescript",
+    "types"
+  ],
+  "author": "XXanderWP",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  }
+}