@rimori/client 1.2.0 → 1.3.0

package/dist/fromRimori/PluginTypes.d.ts

@@ -1,10 +1,13 @@
-export type Plugin = Omit<RimoriPluginConfig, 'context_menu_actions'> & {
+export type Plugin<T extends {} = {}> = Omit<RimoriPluginConfig<T>, 'context_menu_actions'> & {
     version: string;
     endpoint: string;
     assetEndpoint: string;
     context_menu_actions: MenuEntry[];
     release_channel: "alpha" | "beta" | "stable";
 };
+export type ActivePlugin = Plugin<{
+    active?: boolean;
+}>;
 export interface PluginPage {
     id: string;
     name: string;
@@ -43,7 +46,7 @@ export interface ContextMenuAction {
  * Rimori plugin structure representing the complete configuration
  * of a Rimori plugin with all metadata and configuration options.
  */
-export interface RimoriPluginConfig {
+export interface RimoriPluginConfig<T extends {} = {}> {
     id: string;
     /**
      * Basic information about the plugin including branding and core details.
@@ -65,9 +68,9 @@ export interface RimoriPluginConfig {
         /** Optional external URL where the plugin is hosted instead of the default CDN */
         external_hosted_url?: string;
         /** Array of main plugin pages that appear in the application's main navigation (can be disabled using the 'show' flag) */
-        main: PluginPage[];
+        main: (PluginPage & T)[];
         /** Array of sidebar pages that appear in the sidebar for quick access (can be disabled using the 'show' flag) */
-        sidebar: SidebarPage[];
+        sidebar: (SidebarPage & T)[];
         /** Optional path to the plugin's settings/configuration page */
         settings?: string;
         /** Optional array of event topics the plugin pages can listen to for cross-plugin communication */

package/dist/hooks/UseChatHook.js

@@ -1,11 +1,13 @@
 import React from "react";
-import { usePlugin } from "../providers/PluginProvider";
+import { useRimori } from "../providers/PluginProvider";
 export function useChat(tools) {
     const [messages, setMessages] = React.useState([]);
     const [isLoading, setIsLoading] = React.useState(false);
-    const { ai } = usePlugin();
+    const { ai } = useRimori();
     const append = (appendMessages) => {
-        ai.getSteamedText([...messages, ...appendMessages], (id, message, finished, toolInvocations) => {
+        const allMessages = [...messages, ...appendMessages];
+        setMessages(allMessages);
+        ai.getSteamedText(allMessages, (id, message, finished, toolInvocations) => {
             const lastMessage = messages[messages.length - 1];
             setIsLoading(!finished);
             if ((lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.id) === id) {
@@ -13,7 +15,7 @@ export function useChat(tools) {
                 setMessages([...messages, lastMessage]);
             }
             else {
-                setMessages([...messages, ...appendMessages, { id, role: 'assistant', content: message, toolCalls: toolInvocations }]);
+                setMessages([...allMessages, { id, role: 'assistant', content: message, toolCalls: toolInvocations }]);
             }
         }, tools);
     };

package/dist/hooks/UseLogger.d.ts

@@ -0,0 +1,30 @@
+import { Logger } from '../plugin/Logger';
+/**
+ * Hook for initializing the Logger singleton with automatic Rimori client integration.
+ * This hook should be called once at the top level of your plugin.
+ * @param isProduction - Whether the environment is production
+ * @returns Logger instance
+ */
+export declare function useLogger(isProduction: boolean): Logger;
+/**
+ * Hook that provides a logger with automatic Rimori client integration.
+ * This hook should be used after the plugin is fully initialized.
+ * @param isProduction - Whether the environment is production
+ * @returns Logger instance with Rimori client set
+ */
+export declare function useLoggerWithRimori(isProduction: boolean): Logger;
+/**
+ * Hook for managing logs with simplified interface.
+ * Since console methods are overridden globally, this provides utility functions for log management.
+ * @param isProduction - Whether the environment is production
+ * @returns Object with log management methods
+ */
+export declare function useLogging(isProduction: boolean): {
+    sendAllLogs: () => any;
+    sendRecentLogs: (count: number) => any;
+    sendLogsByLevel: (level: "debug" | "info" | "warn" | "error") => any;
+    getStats: () => any;
+    exportLogs: () => any;
+    clearLogs: () => any;
+    restoreConsole: () => any;
+};

package/dist/hooks/UseLogger.js

@@ -0,0 +1,122 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useEffect, useRef } from 'react';
+import { Logger } from '../plugin/Logger';
+import { usePlugin } from './UseChatHook';
+/**
+ * Hook for initializing the Logger singleton with automatic Rimori client integration.
+ * This hook should be called once at the top level of your plugin.
+ * @param isProduction - Whether the environment is production
+ * @returns Logger instance
+ */
+export function useLogger(isProduction) {
+    const { event } = usePlugin();
+    const loggerRef = useRef(null);
+    useEffect(() => {
+        // Initialize logger if not already done
+        if (!loggerRef.current) {
+            loggerRef.current = Logger.getInstance(isProduction);
+        }
+        // Set up automatic log transmission on certain events
+        const handleBeforeUnload = () => {
+            if (loggerRef.current) {
+                // Send recent logs before page unload
+                loggerRef.current.sendRecentLogs(50);
+            }
+        };
+        const handleError = (event) => {
+            // The logger will automatically capture this via console.error override
+            console.error('Unhandled error', {
+                message: event.message,
+                filename: event.filename,
+                lineno: event.lineno,
+                colno: event.colno,
+                error: event.error
+            });
+        };
+        const handleUnhandledRejection = (event) => {
+            // The logger will automatically capture this via console.error override
+            console.error('Unhandled promise rejection', {
+                reason: event.reason
+            });
+        };
+        // Add event listeners
+        window.addEventListener('beforeunload', handleBeforeUnload);
+        window.addEventListener('error', handleError);
+        window.addEventListener('unhandledrejection', handleUnhandledRejection);
+        // Cleanup
+        return () => {
+            window.removeEventListener('beforeunload', handleBeforeUnload);
+            window.removeEventListener('error', handleError);
+            window.removeEventListener('unhandledrejection', handleUnhandledRejection);
+        };
+    }, [isProduction]);
+    // Return a proxy that ensures the logger is available
+    return new Proxy({}, {
+        get(target, prop) {
+            if (!loggerRef.current) {
+                throw new Error('Logger not initialized');
+            }
+            return loggerRef.current[prop];
+        }
+    });
+}
+/**
+ * Hook that provides a logger with automatic Rimori client integration.
+ * This hook should be used after the plugin is fully initialized.
+ * @param isProduction - Whether the environment is production
+ * @returns Logger instance with Rimori client set
+ */
+export function useLoggerWithRimori(isProduction) {
+    const logger = useLogger(isProduction);
+    const { event } = usePlugin();
+    useEffect(() => {
+        // Set up Rimori client integration when the hook is used
+        const setupRimoriIntegration = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Get the plugin ID from the event bus context
+                // This is a simplified approach - in practice, you'd get this from your plugin context
+                const pluginId = 'your-plugin-id'; // This should come from your plugin configuration
+                // Set up a listener for log transmission
+                event.on('global.logger.sendLogs', (data) => __awaiter(this, void 0, void 0, function* () {
+                    if (data.pluginId === pluginId) {
+                        yield logger.sendAllLogs();
+                    }
+                }));
+            }
+            catch (error) {
+                console.warn('Failed to set up Logger with Rimori integration:', error);
+            }
+        });
+        setupRimoriIntegration();
+    }, [event, logger]);
+    return logger;
+}
+/**
+ * Hook for managing logs with simplified interface.
+ * Since console methods are overridden globally, this provides utility functions for log management.
+ * @param isProduction - Whether the environment is production
+ * @returns Object with log management methods
+ */
+export function useLogging(isProduction) {
+    const logger = useLogger(isProduction);
+    return {
+        // Log management
+        sendAllLogs: () => logger.sendAllLogs(),
+        sendRecentLogs: (count) => logger.sendRecentLogs(count),
+        sendLogsByLevel: (level) => logger.sendLogsByLevel(level),
+        // Statistics and export
+        getStats: () => logger.getStats(),
+        exportLogs: () => logger.exportLogs(),
+        clearLogs: () => logger.clearLogs(),
+        // Console restoration (use with caution)
+        restoreConsole: () => logger.restoreConsole()
+    };
+}

package/dist/index.d.ts

@@ -8,3 +8,4 @@ export * from "./utils/PluginUtils";
 export * from "./utils/Language";
 export * from "./fromRimori/PluginTypes";
 export { FirstMessages } from "./components/ai/utils";
+export { AudioController } from "./plugin/AudioController";

package/dist/index.js

@@ -8,3 +8,4 @@ export * from "./utils/difficultyConverter";
 export * from "./utils/PluginUtils";
 export * from "./utils/Language";
 export * from "./fromRimori/PluginTypes";
+export { AudioController } from "./plugin/AudioController";

package/dist/plugin/AudioController.d.ts

@@ -0,0 +1,37 @@
+/**
+ * AudioController is a class that provides methods to record audio. It is a wrapper around the Capacitor Voice Recorder plugin. For more information, see https://github.com/tchvu3/capacitor-voice-recorder.
+ *
+ * @example
+ * const audioController = new AudioController();
+ * await audioController.startRecording();
+ */
+export declare class AudioController {
+    private pluginId;
+    constructor(pluginId: string);
+    /**
+     * Start the recording.
+     *
+     * @example
+     * const audioController = new AudioController();
+     * await audioController.startRecording();
+     * @returns void
+     */
+    startRecording(): Promise<void>;
+    /**
+     * Stop the recording and return the audio data.
+     * @returns The audio data.
+     *
+     * @example
+     * const audioRef = new Audio(`data:${mimeType};base64,${base64Sound}`)
+     * audioRef.oncanplaythrough = () => audioRef.play()
+     * audioRef.load()
+     */
+    stopRecording(): Promise<{
+        recording: Blob;
+        msDuration: number;
+        mimeType: string;
+    }>;
+    pauseRecording(): Promise<boolean>;
+    resumeRecording(): Promise<boolean>;
+    getCurrentStatus(): Promise<"RECORDING" | "PAUSED" | "NONE">;
+}

package/dist/plugin/AudioController.js

@@ -0,0 +1,68 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { EventBus } from "../fromRimori/EventBus";
+/**
+ * AudioController is a class that provides methods to record audio. It is a wrapper around the Capacitor Voice Recorder plugin. For more information, see https://github.com/tchvu3/capacitor-voice-recorder.
+ *
+ * @example
+ * const audioController = new AudioController();
+ * await audioController.startRecording();
+ */
+export class AudioController {
+    constructor(pluginId) {
+        this.pluginId = pluginId;
+    }
+    /**
+     * Start the recording.
+     *
+     * @example
+     * const audioController = new AudioController();
+     * await audioController.startRecording();
+     * @returns void
+     */
+    startRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            EventBus.emit(this.pluginId, "global.microphone.triggerStartRecording");
+        });
+    }
+    /**
+     * Stop the recording and return the audio data.
+     * @returns The audio data.
+     *
+     * @example
+     * const audioRef = new Audio(`data:${mimeType};base64,${base64Sound}`)
+     * audioRef.oncanplaythrough = () => audioRef.play()
+     * audioRef.load()
+     */
+    stopRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield EventBus.request(this.pluginId, "global.microphone.triggerStopRecording");
+            return result.data;
+        });
+    }
+    pauseRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield EventBus.request(this.pluginId, "global.microphone.triggerPauseRecording");
+            return result.data;
+        });
+    }
+    resumeRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield EventBus.request(this.pluginId, "global.microphone.triggerResumeRecording");
+            return result.data;
+        });
+    }
+    getCurrentStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield EventBus.request(this.pluginId, "global.microphone.triggerGetCurrentStatus");
+            return result.data;
+        });
+    }
+}

package/dist/plugin/Logger.d.ts

@@ -0,0 +1,68 @@
+import { RimoriClient } from './RimoriClient';
+/**
+ * Singleton Logger class for Rimori client plugins.
+ * Handles all logging levels, production filtering, and log transmission to Rimori.
+ * Overrides console methods globally for seamless integration.
+ */
+export declare class Logger {
+    private static instance;
+    private isProduction;
+    private logs;
+    private logIdCounter;
+    private originalConsole;
+    private mousePosition;
+    private constructor();
+    /**
+     * Initialize the Logger singleton and override console methods globally.
+     * @param rimori - Rimori client instance
+     * @param isProduction - Whether the environment is production
+     * @returns Logger instance
+     */
+    static getInstance(rimori: RimoriClient, isProduction?: boolean): Logger;
+    private validateIsProduction;
+    /**
+     * Expose log access to global scope for DevTools console access.
+     */
+    private exposeToDevTools;
+    /**
+     * Set up navigation event listeners to clear logs on page changes.
+     */
+    private setupNavigationClearing;
+    /**
+     * Override console methods globally to capture all console calls.
+     */
+    private overrideConsoleMethods;
+    /**
+     * Track mouse position for screenshot context.
+     */
+    private trackMousePosition;
+    /**
+     * Handle console method calls and create log entries.
+     * @param level - Log level
+     * @param args - Console arguments
+     */
+    private handleConsoleCall;
+    /**
+     * Get browser and system information for debugging.
+     * @returns Object with browser and system information
+     */
+    private getBrowserInfo;
+    /**
+     * Capture a screenshot of the current page.
+     * @returns Promise resolving to base64 screenshot or null if failed
+     */
+    private captureScreenshot;
+    /**
+     * Create a log entry with context information.
+     * @param level - Log level
+     * @param message - Log message
+     * @param data - Additional data
+     * @returns Log entry
+     */
+    private createLogEntry;
+    /**
+     * Add a log entry to the internal log array.
+     * @param entry - Log entry to add
+     */
+    private addLogEntry;
+}

package/dist/plugin/Logger.js

@@ -0,0 +1,256 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import html2canvas from 'html2canvas';
+/**
+ * Singleton Logger class for Rimori client plugins.
+ * Handles all logging levels, production filtering, and log transmission to Rimori.
+ * Overrides console methods globally for seamless integration.
+ */
+export class Logger {
+    constructor(rimori, isProduction) {
+        this.logs = [];
+        this.logIdCounter = 0;
+        this.mousePosition = null;
+        this.isProduction = this.validateIsProduction(isProduction);
+        // Store original console methods
+        this.originalConsole = {
+            log: console.log,
+            info: console.info,
+            warn: console.warn,
+            error: console.error,
+            debug: console.debug
+        };
+        // Override console methods globally
+        this.overrideConsoleMethods();
+        // Track mouse position
+        this.trackMousePosition();
+        // Expose logs to global scope for DevTools access
+        this.exposeToDevTools();
+        // Set up navigation clearing
+        this.setupNavigationClearing();
+        rimori.event.respond('logging.requestPluginLogs', () => __awaiter(this, void 0, void 0, function* () {
+            this.addLogEntry(yield this.createLogEntry('info', 'Screenshot capture', undefined, true));
+            const logs = {
+                logs: this.logs,
+                pluginId: rimori.plugin.pluginId,
+                timestamp: new Date().toISOString()
+            };
+            this.logs = [];
+            this.logIdCounter = 0;
+            return logs;
+        }));
+    }
+    /**
+     * Initialize the Logger singleton and override console methods globally.
+     * @param rimori - Rimori client instance
+     * @param isProduction - Whether the environment is production
+     * @returns Logger instance
+     */
+    static getInstance(rimori, isProduction) {
+        if (!Logger.instance) {
+            Logger.instance = new Logger(rimori, isProduction);
+        }
+        return Logger.instance;
+    }
+    validateIsProduction(isProduction) {
+        if (isProduction !== undefined) {
+            return isProduction;
+        }
+        if (typeof window !== 'undefined' && window.location.href) {
+            return !window.location.href.includes('localhost');
+        }
+        return true;
+    }
+    /**
+     * Expose log access to global scope for DevTools console access.
+     */
+    exposeToDevTools() {
+        if (typeof window !== 'undefined') {
+            // Expose a global function to access logs from DevTools console
+            window.getRimoriLogs = () => this.logs;
+        }
+    }
+    /**
+     * Set up navigation event listeners to clear logs on page changes.
+     */
+    setupNavigationClearing() {
+        if (typeof window === 'undefined' || typeof history === 'undefined')
+            return;
+        // Clear logs on browser back/forward
+        window.addEventListener('popstate', () => this.logs = []);
+        // Override history methods to clear logs on programmatic navigation
+        const originalPushState = history.pushState;
+        const originalReplaceState = history.replaceState;
+        history.pushState = (...args) => {
+            originalPushState.apply(history, args);
+            this.logs = [];
+        };
+        history.replaceState = (...args) => {
+            originalReplaceState.apply(history, args);
+            this.logs = [];
+        };
+        // Listen for URL changes (works with React Router and other SPAs)
+        let currentUrl = window.location.href;
+        const checkUrlChange = () => {
+            if (window.location.href !== currentUrl) {
+                currentUrl = window.location.href;
+                this.logs = [];
+            }
+        };
+        // Check for URL changes periodically
+        setInterval(checkUrlChange, 100);
+        // Also listen for hash changes (for hash-based routing)
+        window.addEventListener('hashchange', () => this.logs = []);
+    }
+    /**
+     * Override console methods globally to capture all console calls.
+     */
+    overrideConsoleMethods() {
+        // Override console.log
+        console.log = (...args) => {
+            this.originalConsole.log(...args);
+            this.handleConsoleCall('info', args);
+        };
+        // Override console.info
+        console.info = (...args) => {
+            this.originalConsole.info(...args);
+            this.handleConsoleCall('info', args);
+        };
+        // Override console.warn
+        console.warn = (...args) => {
+            this.originalConsole.warn(...args);
+            this.handleConsoleCall('warn', args);
+        };
+        // Override console.error
+        console.error = (...args) => {
+            this.originalConsole.error(...args);
+            this.handleConsoleCall('error', args);
+        };
+        // Override console.debug
+        console.debug = (...args) => {
+            this.originalConsole.debug(...args);
+            this.handleConsoleCall('debug', args);
+        };
+    }
+    /**
+     * Track mouse position for screenshot context.
+     */
+    trackMousePosition() {
+        if (typeof window !== 'undefined') {
+            const updateMousePosition = (event) => {
+                this.mousePosition = {
+                    x: event.clientX,
+                    y: event.clientY,
+                    timestamp: new Date().toISOString()
+                };
+            };
+            window.addEventListener('mousemove', updateMousePosition);
+            window.addEventListener('click', updateMousePosition);
+        }
+    }
+    /**
+     * Handle console method calls and create log entries.
+     * @param level - Log level
+     * @param args - Console arguments
+     */
+    handleConsoleCall(level, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Skip if this is a production log that shouldn't be stored
+            if (this.isProduction && (level === 'debug' || level === 'info')) {
+                return;
+            }
+            // Convert console arguments to message and data
+            const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
+            const data = args.length > 1 ? args.slice(1) : undefined;
+            const entry = yield this.createLogEntry(level, message, data);
+            this.addLogEntry(entry);
+        });
+    }
+    /**
+     * Get browser and system information for debugging.
+     * @returns Object with browser and system information
+     */
+    getBrowserInfo() {
+        return {
+            userAgent: navigator.userAgent,
+            language: navigator.language,
+            cookieEnabled: navigator.cookieEnabled,
+            onLine: navigator.onLine,
+            screenResolution: `${screen.width}x${screen.height}`,
+            windowSize: `${window.innerWidth}x${window.innerHeight}`,
+            timestamp: new Date().toISOString()
+        };
+    }
+    /**
+     * Capture a screenshot of the current page.
+     * @returns Promise resolving to base64 screenshot or null if failed
+     */
+    captureScreenshot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+                const canvas = yield html2canvas(document.body);
+                const screenshot = canvas.toDataURL('image/png');
+                // this.originalConsole.log("screenshot captured", screenshot)
+                return screenshot;
+            }
+            return null;
+        });
+    }
+    /**
+     * Create a log entry with context information.
+     * @param level - Log level
+     * @param message - Log message
+     * @param data - Additional data
+     * @returns Log entry
+     */
+    createLogEntry(level, message, data, forceScreenshot) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = {};
+            // Add URL if available
+            if (typeof window === 'undefined' || typeof document === 'undefined') {
+                return {
+                    id: `log_${++this.logIdCounter}_${Date.now()}`,
+                    timestamp: new Date().toISOString(),
+                    level,
+                    message,
+                    data,
+                };
+            }
+            context.url = window.location.href;
+            // Add browser info (this method now handles worker context internally)
+            context.browserInfo = this.getBrowserInfo();
+            context.userAgent = context.browserInfo.userAgent;
+            // Add screenshot and mouse position if level is error or warn
+            if (level === 'error' || level === 'warn' || forceScreenshot) {
+                context.screenshot = (yield this.captureScreenshot()) || undefined;
+                context.mousePosition = this.mousePosition || undefined;
+            }
+            return {
+                id: `log_${++this.logIdCounter}_${Date.now()}`,
+                timestamp: new Date().toISOString(),
+                level,
+                message,
+                data,
+                context: context
+            };
+        });
+    }
+    /**
+     * Add a log entry to the internal log array.
+     * @param entry - Log entry to add
+     */
+    addLogEntry(entry) {
+        this.logs.push(entry);
+        // Maintain log size limit (1000 entries)
+        if (this.logs.length > 1000) {
+            this.logs = this.logs.slice(-1000);
+        }
+    }
+}

package/dist/plugin/LoggerExample.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Example of how to integrate the Logger into a plugin's main entry point.
+ * This shows the complete setup process.
+ */
+export declare function initializePluginWithLogger(): Promise<void>;
+export declare function exampleComponentUsage(): {
+    handleUserAction: () => void;
+    handleApiError: (error: Error) => void;
+    handleDeprecatedFeature: () => void;
+};
+export declare function exampleLogManagement(): {
+    sendLogsToRimori: () => Promise<void>;
+    getLogStatistics: () => any;
+    exportLogsForDebugging: () => void;
+    clearOldLogs: () => void;
+};