@rimori/client 1.1.10 → 1.3.0

package/dist/{controller → core/controller}/VoiceController.js

@@ -7,16 +7,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-export function getSTTResponse(supabase, audio) {
+export function getSTTResponse(backendUrl, audio, token) {
     return __awaiter(this, void 0, void 0, function* () {
         const formData = new FormData();
         formData.append('file', audio);
-        return yield supabase.functions.invoke('speech', { method: 'POST', body: formData }).then(({ data }) => data.text);
+        return yield fetch(`${backendUrl}/voice/stt`, {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${token}` },
+            body: formData,
+        }).then(r => r.json()).then(r => {
+            // console.log("STT response: ", r);
+            return r.text;
+        });
     });
 }
-export function getTTSResponse(supabaseUrl, request, token) {
+export function getTTSResponse(backendUrl, request, token) {
     return __awaiter(this, void 0, void 0, function* () {
-        return yield fetch(`${supabaseUrl}/functions/v1/speech`, {
+        return yield fetch(`${backendUrl}/voice/tts`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',

package/dist/core/core.d.ts

@@ -0,0 +1,14 @@
+export * from "../fromRimori/PluginTypes";
+export * from "../plugin/PluginController";
+export * from "../plugin/RimoriClient";
+export * from "../utils/difficultyConverter";
+export * from "../utils/Language";
+export * from "../utils/PluginUtils";
+export * from "../worker/WorkerSetup";
+export { EventBusMessage } from "../fromRimori/EventBus";
+export { Buddy, UserInfo } from "./controller/SettingsController";
+export { SharedContent } from "./controller/SharedContentController";
+export { Message, OnLLMResponse, ToolInvocation } from "./controller/AIController";
+export { MacroAccomplishmentPayload, MicroAccomplishmentPayload } from "../plugin/AccomplishmentHandler";
+export { Tool } from "../fromRimori/PluginTypes";
+export { SharedContentObjectRequest } from "./controller/SharedContentController";

package/dist/core/core.js

@@ -0,0 +1,8 @@
+// Core functionality exports
+export * from "../fromRimori/PluginTypes";
+export * from "../plugin/PluginController";
+export * from "../plugin/RimoriClient";
+export * from "../utils/difficultyConverter";
+export * from "../utils/Language";
+export * from "../utils/PluginUtils";
+export * from "../worker/WorkerSetup";

package/dist/{plugin/fromRimori → fromRimori}/EventBus.d.ts

@@ -52,7 +52,7 @@ export declare class EventBusHandler {
      * @param topics - The topic of the event.
      * @param handler - The handler to be called when the event is emitted.
      * @param ignoreSender - The senders to ignore.
-     * @returns The ids of the listeners.
+     * @returns An EventListener object containing an off() method to unsubscribe the listeners.
      */
     on<T = EventPayload>(topics: string | string[], handler: EventHandler<T>, ignoreSender?: string[]): EventListener;
     /**
@@ -60,9 +60,9 @@ export declare class EventBusHandler {
      * @param sender - The sender of the event.
      * @param topic - The topic of the event.
      * @param handler - The handler to be called when the event is received. The handler returns the data to be emitted. Can be a static object or a function.
-     * @returns The ids of the listeners.
+     * @returns An EventListener object containing an off() method to unsubscribe the listeners.
      */
-    respond(sender: string, topic: string, handler: EventPayload | ((data: EventBusMessage) => EventPayload | Promise<EventPayload>)): EventListener;
+    respond(sender: string, topic: string | string[], handler: EventPayload | ((data: EventBusMessage) => EventPayload | Promise<EventPayload>)): EventListener;
     /**
      * Subscribes to an event on the event bus. The handler will be called once and then removed.
      * @param topic - The topic of the event.

package/dist/{plugin/fromRimori → fromRimori}/EventBus.js

@@ -11,7 +11,7 @@ export class EventBusHandler {
     constructor() {
         this.listeners = new Map();
         this.responseResolvers = new Map();
-        this.debugEnabled = true;
+        this.debugEnabled = false;
         this.evName = "";
         //private constructor
     }
@@ -90,7 +90,7 @@ export class EventBusHandler {
      * @param topics - The topic of the event.
      * @param handler - The handler to be called when the event is emitted.
      * @param ignoreSender - The senders to ignore.
-     * @returns The ids of the listeners.
+     * @returns An EventListener object containing an off() method to unsubscribe the listeners.
      */
     on(topics, handler, ignoreSender = []) {
         const ids = this.toArray(topics).map(topic => {
@@ -117,16 +117,33 @@ export class EventBusHandler {
      * @param sender - The sender of the event.
      * @param topic - The topic of the event.
      * @param handler - The handler to be called when the event is received. The handler returns the data to be emitted. Can be a static object or a function.
-     * @returns The ids of the listeners.
+     * @returns An EventListener object containing an off() method to unsubscribe the listeners.
      */
     respond(sender, topic, handler) {
-        const listener = this.on(topic, (data) => __awaiter(this, void 0, void 0, function* () {
-            const response = typeof handler === "function" ? yield handler(data) : handler;
-            this.emit(sender, topic, response, data.eventId);
-        }), [sender]);
-        this.logIfDebug(`Added respond listener ` + sender + " to topic " + topic, { listener, sender });
+        const topics = Array.isArray(topic) ? topic : [topic];
+        const listeners = topics.map(topic => {
+            const blackListedEventIds = [];
+            //To allow event communication inside the same plugin the sender needs to be ignored but the events still need to be checked for the same event just reaching the subscriber to prevent infinite loops
+            const finalIgnoreSender = !topic.startsWith("self.") ? [sender] : [];
+            const listener = this.on(topic, (data) => __awaiter(this, void 0, void 0, function* () {
+                if (blackListedEventIds.includes(data.eventId)) {
+                    // console.log("BLACKLISTED EVENT ID", data.eventId);
+                    return;
+                }
+                blackListedEventIds.push(data.eventId);
+                if (blackListedEventIds.length > 20) {
+                    blackListedEventIds.shift();
+                }
+                const response = typeof handler === "function" ? yield handler(data) : handler;
+                this.emit(sender, topic, response, data.eventId);
+            }), finalIgnoreSender);
+            this.logIfDebug(`Added respond listener ` + sender + " to topic " + topic, { listener, sender });
+            return {
+                off: () => listener.off()
+            };
+        });
         return {
-            off: () => listener.off()
+            off: () => listeners.forEach(listener => listener.off())
         };
     }
     /**

package/dist/fromRimori/PluginTypes.d.ts

@@ -0,0 +1,174 @@
+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;
+    url: string;
+    show: boolean;
+    description: string;
+    root: "vocabulary" | "grammar" | "reading" | "listening" | "watching" | "writing" | "speaking" | "other" | "community";
+    action?: {
+        key: string;
+        parameters: ObjectTool;
+    };
+}
+export interface SidebarPage {
+    id: string;
+    name: string;
+    description: string;
+    url: string;
+    icon: string;
+}
+export interface MenuEntry {
+    plugin_id: string;
+    action_key: string;
+    text: string;
+    icon?: React.ReactNode;
+}
+export type MainPanelAction = {
+    plugin_id: string;
+    action_key: string;
+} & Record<string, string>;
+export interface ContextMenuAction {
+    text: string;
+    plugin_id: string;
+    action_key: string;
+}
+/**
+ * Rimori plugin structure representing the complete configuration
+ * of a Rimori plugin with all metadata and configuration options.
+ */
+export interface RimoriPluginConfig<T extends {} = {}> {
+    id: string;
+    /**
+     * Basic information about the plugin including branding and core details.
+     */
+    info: {
+        /** The display name of the plugin shown to users */
+        title: string;
+        /** Detailed description introducing the plugin */
+        description: string;
+        /** relative or absolute URL or path to the plugin's logo/icon image */
+        logo: string;
+        /** Optional website URL for the plugin's homepage or link to plugins owner for contributions */
+        website?: string;
+    };
+    /**
+     * Configuration for different types of pages.
+     */
+    pages: {
+        /** 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 & T)[];
+        /** Array of sidebar pages that appear in the sidebar for quick access (can be disabled using the 'show' flag) */
+        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 */
+        topics?: string[];
+    };
+    /**
+     * Context menu actions that the plugin registers to appear in right-click menus throughout the application.
+     */
+    context_menu_actions: Omit<MenuEntry, "plugin_id">[];
+    /**
+     * Documentation paths for different types of plugin documentation.
+     */
+    documentation: {
+        /** Path to the general overview documentation. It's shown upon installation of the plugin. */
+        overview_path: string;
+        /** Path to user-facing documentation and guides */
+        user_path: string;
+        /** Path to developer documentation for plugin development */
+        developer_path: string;
+    };
+    /**
+     * Configuration for the plugin's web worker if it uses background processing or exposes actions to other plugins.
+     */
+    worker?: {
+        /** Relative path to the web worker JavaScript file. Mostly it's 'web-worker.js' which is located in the public folder. */
+        url: string;
+        /** Optional array of event topics the worker should listen to in addition to events having the pluginId in the topic. Can be a wildcard. Example: 'global.topic.*' or 'pluginId.*' */
+        topics?: string[];
+    };
+}
+export interface Tool {
+    name: string;
+    description: string;
+    parameters: {
+        name: string;
+        description: string;
+        type: "string" | "number" | "boolean";
+    }[];
+    execute?: (args: Record<string, any>) => Promise<unknown> | unknown | void;
+}
+/**
+ * The tool definition structure is used for LLM function calling and plugin action parameters.
+ * It defines the schema for tools that can be used by Language Learning Models (LLMs)
+ * and plugin actions.
+ *
+ * @example
+ * ```typescript
+ * const flashcardTool: Tool = {
+ *   total_amount: {
+ *     type: 'string',
+ *     enum: ['default', '10', '20', '50'],
+ *     description: 'Number of flashcards to practice'
+ *   },
+ *   deck: {
+ *     type: 'string',
+ *     enum: ['latest', 'random', 'oldest', 'mix', 'best_known'],
+ *     description: 'Type of deck to practice'
+ *   }
+ * };
+ * ```
+ *
+ */
+export type ObjectTool = {
+    [key: string]: ToolParameter;
+};
+/**
+ * Parameter definition for LLM tools and plugin actions.
+ * Defines the structure, validation rules, and metadata for individual tool parameters.
+ * Used to create type-safe interfaces between LLMs, plugins, and the Rimori platform.
+ */
+interface ToolParameter {
+    /** The data type of the parameter - can be primitive, nested object, or array */
+    type: ToolParameterType;
+    /** Human-readable description of the parameter's purpose and usage */
+    description: string;
+    /** Optional array of allowed values for enumerated parameters */
+    enum?: string[];
+    /** Whether the parameter is optional */
+    optional?: boolean;
+}
+/**
+ * Union type defining all possible parameter types for LLM tools.
+ * Supports primitive types, nested objects for complex data structures,
+ * and arrays of objects for collections. The tuple notation [{}] indicates
+ * arrays of objects with a specific structure.
+ *
+ * @example Primitive: 'string' | 'number' | 'boolean'
+ * @example Nested object: { name: { type: 'string' }, age: { type: 'number' } }
+ * @example Array of objects: [{ id: { type: 'string' }, value: { type: 'number' } }]
+ */
+type ToolParameterType = PrimitiveType | {
+    [key: string]: ToolParameter;
+} | [{
+    [key: string]: ToolParameter;
+}];
+/**
+ * Primitive data types supported by the LLM tool system.
+ * These align with JSON schema primitive types and TypeScript basic types.
+ */
+type PrimitiveType = 'string' | 'number' | 'boolean';
+export {};

package/dist/hooks/UseChatHook.d.ts

@@ -1,5 +1,6 @@
 import React from "react";
-import { Message, Tool } from "../controller/AIController";
+import { Tool } from "../fromRimori/PluginTypes";
+import { Message } from "../core/controller/AIController";
 export declare function useChat(tools?: Tool[]): {
     messages: Message[];
     append: (appendMessages: Message[]) => void;

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 { llm } = usePlugin();
+    const { ai } = useRimori();
     const append = (appendMessages) => {
-        llm.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, 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

@@ -1,8 +1,11 @@
-export * from './core';
 export * from './components';
 export * from "./hooks/UseChatHook";
-export * from "./plugin/RimoriClient";
+export * from "./plugin/PluginController";
 export * from "./providers/PluginProvider";
+export * from "./cli/types/DatabaseTypes";
 export * from "./utils/difficultyConverter";
 export * from "./utils/PluginUtils";
-export * from "./plugin/PluginController";
+export * from "./utils/Language";
+export * from "./fromRimori/PluginTypes";
+export { FirstMessages } from "./components/ai/utils";
+export { AudioController } from "./plugin/AudioController";

package/dist/index.js

@@ -1,9 +1,11 @@
 // Re-export everything
-export * from './core';
 export * from './components';
 export * from "./hooks/UseChatHook";
-export * from "./plugin/RimoriClient";
+export * from "./plugin/PluginController";
 export * from "./providers/PluginProvider";
+export * from "./cli/types/DatabaseTypes";
 export * from "./utils/difficultyConverter";
 export * from "./utils/PluginUtils";
-export * from "./plugin/PluginController";
+export * from "./utils/Language";
+export * from "./fromRimori/PluginTypes";
+export { AudioController } from "./plugin/AudioController";

package/dist/plugin/AccomplishmentHandler.d.ts

@@ -1,4 +1,4 @@
-import { EventBusMessage } from "./fromRimori/EventBus";
+import { EventBusMessage } from "../fromRimori/EventBus";
 export type AccomplishmentMessage = EventBusMessage<MicroAccomplishmentPayload>;
 export declare const skillCategories: readonly ["reading", "listening", "speaking", "writing", "learning", "community"];
 interface BaseAccomplishmentPayload {

package/dist/plugin/AccomplishmentHandler.js

@@ -1,4 +1,4 @@
-import { EventBus } from "./fromRimori/EventBus";
+import { EventBus } from "../fromRimori/EventBus";
 export const skillCategories = ["reading", "listening", "speaking", "writing", "learning", "community"];
 export class AccomplishmentHandler {
     constructor(pluginId) {

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;
+        });
+    }
+}