@rimori/react-client 0.1.0 → 0.1.1

package/dist/rimori-client/src/cli/types/DatabaseTypes.d.ts

@@ -1,103 +0,0 @@
-/**
- * Supported database column data types for table schema definitions.
- */
-type DbColumnType = 'decimal' | 'integer' | 'text' | 'boolean' | 'json' | 'timestamp' | 'uuid';
-/**
- * Foreign key relationship configuration with cascade delete support.
- * Defines a relationship where the source record is deleted when the destination record is deleted.
- */
-interface ForeignKeyRelation {
-    /** The target table that this column references */
-    references_table: string;
-    /** The target column in the referenced table (defaults to 'id') */
-    references_column?: string;
-    /** Whether to cascade delete when the referenced record is deleted */
-    on_delete_cascade: boolean;
-}
-/**
- * Database column definition with support for types, constraints, and relationships.
- */
-export interface DbColumnDefinition {
-    /** The data type of the column */
-    type: DbColumnType;
-    /** Human-readable description of the column's purpose */
-    description: string;
-    /** Whether the column can contain null values */
-    nullable?: boolean;
-    /** Whether the column has a unique constraint */
-    unique?: boolean;
-    /** Default value for the column. can also use sql functions like now(), auth.uid() or gen_random_uuid() */
-    default_value?: string | number | boolean;
-    /** Array of allowed values for enumerated columns */
-    /** Foreign key relationship configuration */
-    foreign_key?: ForeignKeyRelation;
-    /** The name of the column before it was renamed. */
-    old_name?: string;
-    /** Whether the column is deprecated. The column gets renamed to column_name_old. To fully remove the column, first set deprecated to true and then after a release, remove the column from the table definition. */
-    deprecated?: boolean;
-    /** Whether the column is a primary key */
-    /** Restrictions for the column. If the column is restricted, the permission is further restricted. E.g. if the column is restricted to user, then the user can only read the column if they have the right permission.
-     * Example: Denying users to update the column, but allowing the moderator to update the column.
-     */
-    restrict?: {
-        /** Restrictions for the user */
-        user: Partial<Omit<DbPermissionDefinition, 'delete'>>;
-        /** Restrictions for the moderator */
-        moderator?: Partial<Omit<DbPermissionDefinition, 'delete'>>;
-    };
-}
-/**
- * Base table structure that all database tables inherit.
- * Includes standard audit fields for tracking creation and ownership.
- */
-interface BaseTableStructure {
-    /** Unique identifier for the record */
-    id: DbColumnDefinition;
-    /** Timestamp when the record was created */
-    created_at: DbColumnDefinition;
-    /** ID of the user who created the record */
-    created_by: DbColumnDefinition;
-}
-/**
- * Complete database table schema definition.
- * Defines the structure, constraints, and relationships for a database table.
- */
-export interface DbTableDefinition {
-    /** Name of the database table */
-    table_name: string;
-    /** Description of the table's purpose and usage */
-    description: string;
-    /** Permissions for the table */
-    permissions: {
-        user: DbPermissionDefinition;
-        moderator?: DbPermissionDefinition;
-    };
-    /** Column definitions for the table */
-    columns: {
-        [column_name: string]: DbColumnDefinition;
-    };
-}
-/**
- * Permission definition for a database table.
- * NONE means the action is not allowed.
- * OWN means only do the action on your own records.
- * ALL means do the action on all records.
- *
- * Defines the permissions for a database table.
- */
-export type DbPermission = 'NONE' | 'OWN' | 'ALL';
-/**
- * Permission definition for a database table.
- * Defines the permissions for a database table.
- */
-export interface DbPermissionDefinition {
-    read: DbPermission;
-    insert: DbPermission;
-    update: DbPermission;
-    delete: DbPermission;
-}
-/**
- * Full table definition that includes automatically generated fields.
- */
-export type FullTable<T extends Record<string, DbColumnDefinition>> = T & BaseTableStructure;
-export {};

package/dist/rimori-client/src/cli/types/DatabaseTypes.js

@@ -1,2 +0,0 @@
-// Database table structure definitions
-export {};

package/dist/rimori-client/src/controller/AIController.d.ts

@@ -1,15 +0,0 @@
-import { Tool } from '../fromRimori/PluginTypes';
-export interface ToolInvocation {
-    toolCallId: string;
-    toolName: string;
-    args: Record<string, string>;
-}
-export interface Message {
-    id?: string;
-    role: 'user' | 'assistant' | 'system';
-    content: string;
-    toolCalls?: ToolInvocation[];
-}
-export declare function generateText(backendUrl: string, messages: Message[], tools: Tool[], token: string): Promise<any>;
-export type OnLLMResponse = (id: string, response: string, finished: boolean, toolInvocations?: ToolInvocation[]) => void;
-export declare function streamChatGPT(backendUrl: string, messages: Message[], tools: Tool[], onResponse: OnLLMResponse, token: string): Promise<void>;

package/dist/rimori-client/src/controller/AIController.js

@@ -1,255 +0,0 @@
-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());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-export function generateText(backendUrl, messages, tools, token) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const response = yield fetch(`${backendUrl}/ai/llm`, {
-            method: 'POST',
-            body: JSON.stringify({ messages, tools }),
-            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-        });
-        return yield response.json();
-    });
-}
-export function streamChatGPT(backendUrl, messages, tools, onResponse, token) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const messageId = Math.random().toString(36).substring(3);
-        const currentMessages = [...messages];
-        console.log('Starting streamChatGPT with:', {
-            messageId,
-            messageCount: messages.length,
-            toolCount: tools.length,
-            backendUrl,
-        });
-        while (true) {
-            const messagesForApi = currentMessages.map((_a) => {
-                var { id } = _a, rest = __rest(_a, ["id"]);
-                return rest;
-            });
-            try {
-                const response = yield fetch(`${backendUrl}/ai/llm`, {
-                    method: 'POST',
-                    body: JSON.stringify({ messages: messagesForApi, tools, stream: true }),
-                    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-                });
-                if (!response.ok) {
-                    throw new Error(`HTTP error! status: ${response.status}`);
-                }
-                if (!response.body) {
-                    console.error('No response body.');
-                    return;
-                }
-                const reader = response.body.getReader();
-                const decoder = new TextDecoder('utf-8');
-                let content = '';
-                let done = false;
-                const toolInvocations = [];
-                let currentTextId = '';
-                let isToolCallMode = false;
-                let buffer = ''; // Buffer for incomplete chunks
-                while (!done) {
-                    const { value, done: readerDone } = yield reader.read();
-                    if (value) {
-                        const chunk = decoder.decode(value, { stream: true });
-                        buffer += chunk;
-                        // Split by lines, but handle incomplete lines
-                        const lines = buffer.split('\n');
-                        // Keep the last line in buffer if it's incomplete
-                        if (lines.length > 1) {
-                            buffer = lines.pop() || '';
-                        }
-                        for (const line of lines) {
-                            if (line.trim() === '')
-                                continue;
-                            // Handle the new streaming format
-                            if (line.startsWith('data: ')) {
-                                const dataStr = line.substring(6); // Remove 'data: ' prefix
-                                // Handle [DONE] marker
-                                if (dataStr === '[DONE]') {
-                                    done = true;
-                                    break;
-                                }
-                                try {
-                                    const data = JSON.parse(dataStr);
-                                    // Log the first message to understand the format
-                                    if (!content && !isToolCallMode) {
-                                        // console.log('First stream message received:', data);
-                                    }
-                                    switch (data.type) {
-                                        case 'start':
-                                            // Stream started, no action needed
-                                            // console.log('Stream started');
-                                            break;
-                                        case 'start-step':
-                                            // Step started, no action needed
-                                            // console.log('Step started');
-                                            break;
-                                        case 'reasoning-start':
-                                            // Reasoning started, no action needed
-                                            console.log('Reasoning started:', data.id);
-                                            break;
-                                        case 'reasoning-end':
-                                            // Reasoning ended, no action needed
-                                            console.log('Reasoning ended:', data.id);
-                                            break;
-                                        case 'text-start':
-                                            // Text generation started, store the ID
-                                            currentTextId = data.id;
-                                            console.log('Text generation started:', data.id);
-                                            break;
-                                        case 'text-delta':
-                                            // Text delta received, append to content
-                                            if (data.delta) {
-                                                content += data.delta;
-                                                onResponse(messageId, content, false);
-                                            }
-                                            break;
-                                        case 'text-end':
-                                            // Text generation ended
-                                            console.log('Text generation ended:', data.id);
-                                            break;
-                                        case 'finish-step':
-                                            // Step finished, no action needed
-                                            // console.log('Step finished');
-                                            break;
-                                        case 'finish':
-                                            // Stream finished
-                                            // console.log('Stream finished');
-                                            done = true;
-                                            break;
-                                        // Additional message types that might be present in the AI library
-                                        case 'tool-call':
-                                        case 'tool-input-available': //for now input calls should be handled the same way as tool calls
-                                            // Tool call initiated
-                                            console.log('Tool call initiated:', data);
-                                            isToolCallMode = true;
-                                            if (data.toolCallId && data.toolName && (data.args || data.input)) {
-                                                toolInvocations.push({
-                                                    toolCallId: data.toolCallId,
-                                                    toolName: data.toolName,
-                                                    args: data.args || data.input,
-                                                });
-                                            }
-                                            break;
-                                        case 'tool-input-delta': //for now input calls should be handled the same way as tool calls
-                                        case 'tool-call-delta':
-                                            // Tool call delta (for streaming tool calls)
-                                            console.log('Tool call delta:', data);
-                                            break;
-                                        case 'tool-call-end':
-                                            // Tool call completed
-                                            console.log('Tool call completed:', data);
-                                            break;
-                                        case 'tool-result':
-                                            // Tool execution result
-                                            console.log('Tool result:', data);
-                                            break;
-                                        case 'error':
-                                            // Error occurred
-                                            console.error('Stream error:', data);
-                                            break;
-                                        case 'usage':
-                                            // Usage information
-                                            console.log('Usage info:', data);
-                                            break;
-                                        case 'model':
-                                            // Model information
-                                            console.log('Model info:', data);
-                                            break;
-                                        case 'stop':
-                                            // Stop signal
-                                            console.log('Stop signal received');
-                                            done = true;
-                                            break;
-                                        default:
-                                            // Unknown type, log for debugging
-                                            console.log('Unknown stream type:', data.type, data);
-                                            break;
-                                    }
-                                }
-                                catch (error) {
-                                    console.error('Error parsing stream data:', error, dataStr);
-                                }
-                            }
-                        }
-                    }
-                    if (readerDone) {
-                        done = true;
-                    }
-                }
-                // Check if we have content or if this was a tool call response
-                if (content || toolInvocations.length > 0) {
-                    currentMessages.push({
-                        id: messageId,
-                        role: 'assistant',
-                        content: content,
-                        toolCalls: toolInvocations.length > 0 ? toolInvocations : undefined,
-                    });
-                }
-                // Handle tool call scenario if tools were provided
-                if (tools.length > 0 && toolInvocations.length > 0) {
-                    console.log('Tool calls detected, executing tools...');
-                    const toolResults = [];
-                    for (const toolInvocation of toolInvocations) {
-                        const tool = tools.find((t) => t.name === toolInvocation.toolName);
-                        if (tool && tool.execute) {
-                            try {
-                                const result = yield tool.execute(toolInvocation.args);
-                                toolResults.push({
-                                    id: Math.random().toString(36).substring(3),
-                                    role: 'user',
-                                    content: `Tool '${toolInvocation.toolName}' returned: ${JSON.stringify(result)}`,
-                                });
-                            }
-                            catch (error) {
-                                console.error(`Error executing tool ${toolInvocation.toolName}:`, error);
-                                toolResults.push({
-                                    id: Math.random().toString(36).substring(3),
-                                    role: 'user',
-                                    content: `Tool '${toolInvocation.toolName}' failed with error: ${error}`,
-                                });
-                            }
-                        }
-                    }
-                    if (toolResults.length > 0) {
-                        currentMessages.push(...toolResults);
-                        // Continue the loop to handle the next response
-                        continue;
-                    }
-                }
-                // Since the new format doesn't seem to support tool calls in the same way,
-                // we'll assume the stream is complete when we reach the end
-                // If tools are provided and no content was generated, this might indicate a tool call
-                if (tools.length > 0 && !content && !isToolCallMode) {
-                    // This might be a tool call scenario, but we need more information
-                    // For now, we'll just finish the stream
-                    console.log('No content generated, but tools provided - might be tool call scenario');
-                }
-                onResponse(messageId, content, true, toolInvocations);
-                return;
-            }
-            catch (error) {
-                console.error('Error in streamChatGPT:', error);
-                onResponse(messageId, `Error: ${error instanceof Error ? error.message : String(error)}`, true, []);
-                return;
-            }
-        }
-    });
-}

package/dist/rimori-client/src/controller/AccomplishmentController.d.ts

@@ -1,38 +0,0 @@
-import { EventBusMessage } from '../fromRimori/EventBus';
-export type AccomplishmentMessage = EventBusMessage<MicroAccomplishmentPayload>;
-export declare const skillCategories: readonly ["reading", "listening", "speaking", "writing", "learning", "community"];
-interface BaseAccomplishmentPayload {
-    type: 'micro' | 'macro';
-    skillCategory: (typeof skillCategories)[number];
-    accomplishmentKeyword: string;
-    description: string;
-    meta?: {
-        key: string;
-        value: string | number | boolean;
-        description: string;
-    }[];
-}
-export interface MicroAccomplishmentPayload extends BaseAccomplishmentPayload {
-    type: 'micro';
-}
-export interface MacroAccomplishmentPayload extends BaseAccomplishmentPayload {
-    type: 'macro';
-    errorRatio: number;
-    durationMinutes: number;
-}
-export type AccomplishmentPayload = MicroAccomplishmentPayload | MacroAccomplishmentPayload;
-export declare class AccomplishmentController {
-    private pluginId;
-    constructor(pluginId: string);
-    emitAccomplishment(payload: Omit<AccomplishmentPayload, 'type'>): void;
-    private validateAccomplishment;
-    private sanitizeAccomplishment;
-    private getDecoupledTopic;
-    /**
-     * Subscribe to accomplishment events
-     * @param accomplishmentTopic - The topic of the accomplishment event. The pattern can be any pattern of plugin.skillCategory.accomplishmentKeyword or an * as wildcard for any plugin, skill category or accomplishment keyword
-     * @param callback - The callback function to be called when the accomplishment event is triggered
-     */
-    subscribe(accomplishmentTopics: string | string[] | undefined, callback: (payload: EventBusMessage<AccomplishmentPayload>) => void): void;
-}
-export {};

package/dist/rimori-client/src/controller/AccomplishmentController.js

@@ -1,112 +0,0 @@
-import { EventBus } from '../fromRimori/EventBus';
-export const skillCategories = ['reading', 'listening', 'speaking', 'writing', 'learning', 'community'];
-export class AccomplishmentController {
-    constructor(pluginId) {
-        this.pluginId = pluginId;
-    }
-    emitAccomplishment(payload) {
-        const accomplishmentPayload = Object.assign(Object.assign({}, payload), { type: 'durationMinutes' in payload ? 'macro' : 'micro' });
-        this.validateAccomplishment(accomplishmentPayload);
-        const sanitizedPayload = this.sanitizeAccomplishment(accomplishmentPayload);
-        const topic = 'global.accomplishment.trigger' + (accomplishmentPayload.type === 'macro' ? 'Macro' : 'Micro');
-        EventBus.emit(this.pluginId, topic, sanitizedPayload);
-    }
-    validateAccomplishment(payload) {
-        if (!skillCategories.includes(payload.skillCategory)) {
-            throw new Error(`Invalid skill category: ${payload.skillCategory}`);
-        }
-        //regex validate accomplishmentKeyword
-        if (!/^[a-z_-]+$/.test(payload.accomplishmentKeyword)) {
-            throw new Error(`The accomplishment keyword: ${payload.accomplishmentKeyword} is invalid. Only lowercase letters, minuses and underscores are allowed`);
-        }
-        //description is required
-        if (payload.description.length < 10) {
-            throw new Error('Description is too short');
-        }
-        //check that the type is valid
-        if (!['micro', 'macro'].includes(payload.type)) {
-            throw new Error('Invalid accomplishment type ' + payload.type);
-        }
-        //durationMinutes is required
-        if (payload.type === 'macro' && payload.durationMinutes < 4) {
-            throw new Error('The duration must be at least 4 minutes');
-        }
-        //errorRatio is required
-        if (payload.type === 'macro' && (payload.errorRatio < 0 || payload.errorRatio > 1)) {
-            throw new Error('The error ratio must be between 0 and 1');
-        }
-        //regex check meta data key
-        if (payload.meta) {
-            payload.meta.forEach((meta) => {
-                if (!/^[a-z_]+$/.test(meta.key)) {
-                    throw new Error('Invalid meta data key ' + meta.key + ', only lowercase letters and underscores are allowed');
-                }
-            });
-        }
-    }
-    sanitizeAccomplishment(payload) {
-        var _a;
-        payload.description = payload.description.replace(/[^\x20-\x7E]/g, '');
-        (_a = payload.meta) === null || _a === void 0 ? void 0 : _a.forEach((meta) => {
-            meta.description = meta.description.replace(/[^\x20-\x7E]/g, '');
-        });
-        return payload;
-    }
-    getDecoupledTopic(topic) {
-        const [plugin, skillCategory, accomplishmentKeyword] = topic.split('.');
-        return {
-            plugin: plugin || '*',
-            skillCategory: skillCategory || '*',
-            accomplishmentKeyword: accomplishmentKeyword || '*',
-        };
-    }
-    /**
-     * Subscribe to accomplishment events
-     * @param accomplishmentTopic - The topic of the accomplishment event. The pattern can be any pattern of plugin.skillCategory.accomplishmentKeyword or an * as wildcard for any plugin, skill category or accomplishment keyword
-     * @param callback - The callback function to be called when the accomplishment event is triggered
-     */
-    subscribe(accomplishmentTopics = '*', callback) {
-        if (typeof accomplishmentTopics === 'string') {
-            accomplishmentTopics = [accomplishmentTopics];
-        }
-        accomplishmentTopics.forEach((accomplishmentTopic) => {
-            const topicLength = accomplishmentTopic.split('.').length;
-            if (topicLength === 1) {
-                accomplishmentTopic += '.*.*';
-            }
-            else if (topicLength === 2) {
-                accomplishmentTopic += '.*';
-            }
-            else if (topicLength !== 3) {
-                throw new Error('Invalid accomplishment topic pattern. The pattern must be plugin.skillCategory.accomplishmentKeyword or an * as wildcard for any plugin, skill category or accomplishment keyword');
-            }
-            EventBus.on(['global.accomplishment.triggerMicro', 'global.accomplishment.triggerMacro'], (event) => {
-                const { plugin, skillCategory, accomplishmentKeyword } = this.getDecoupledTopic(accomplishmentTopic);
-                if (plugin !== '*' && event.sender !== plugin)
-                    return;
-                if (skillCategory !== '*' && event.data.skillCategory !== skillCategory)
-                    return;
-                if (accomplishmentKeyword !== '*' && event.data.accomplishmentKeyword !== accomplishmentKeyword)
-                    return;
-                callback(event);
-            }, [this.pluginId]);
-        });
-    }
-}
-// const accomplishmentHandler = AccomplishmentHandler.getInstance("my-plugin");
-// accomplishmentHandler.subscribe("*", (payload) => {
-//   console.log(payload);
-// });
-// accomplishmentHandler.emitAccomplishment({
-//   skillCategory: "reading",
-//   accomplishmentKeyword: "chapter",
-//   description: "Read chapter 1 of the book",
-//   durationMinutes: 10,
-//   meta: [
-//     {
-//       key: "book",
-//       value: "The Great Gatsby",
-//       description: "The book I read",
-//     },
-//   ],
-// });

package/dist/rimori-client/src/controller/AudioController.d.ts

@@ -1,37 +0,0 @@
-/**
- * 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/rimori-client/src/controller/AudioController.js

@@ -1,68 +0,0 @@
-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;
-        });
-    }
-}