@rimori/client 2.5.5 → 2.5.6

package/dist/cli/types/DatabaseTypes.d.ts

@@ -61,10 +61,12 @@ interface BaseTableStructure {
     created_by: DbColumnDefinition;
 }
 /**
- * Complete database table schema definition.
- * Defines the structure, constraints, and relationships for a database table.
+ * Normal database table schema definition.
+ * Defines the structure, constraints, and relationships for a standard database table.
  */
-export interface DbTableDefinition {
+export interface DbNormalTableDefinition {
+    /** Type discriminator for normal tables */
+    type: 'table';
     /** Name of the database table */
     table_name: string;
     /** Description of the table's purpose and usage */
@@ -83,6 +85,37 @@ export interface DbTableDefinition {
         [column_name: string]: DbColumnDefinition;
     };
 }
+/**
+ * Shared content table schema definition.
+ * Defines the structure for community-shared content tables with automatic columns and verification.
+ * Table naming: {pluginId}_sc_{table_name}
+ * Automatic columns: title (text), keywords (text[]), verified (boolean), embedding (vector)
+ * Hardcoded permissions: read ALL public+own, insert/update/delete OWN
+ */
+export interface DbSharedContentTableDefinition {
+    /** Type discriminator for shared content tables */
+    type: 'shared_content';
+    /** Name of the database table (will become {pluginId}_sc_{table_name}) */
+    table_name: string;
+    /** Description of the table's purpose and usage */
+    description: string;
+    /** AI prompt for generating content. Supports placeholders like {{topic}}, {{level}}, etc. */
+    instructions: string;
+    /** Optional AI prompt to verify content quality before marking as verified */
+    verification_prompt: string;
+    /** Column definitions for the table (excluding auto-generated columns) */
+    columns: {
+        [column_name: string]: DbColumnDefinition & {
+            /** Whether the column is used for LLM generation. If not set, the column is not used for LLM generation. */
+            expose_to_llm?: boolean;
+        };
+    };
+}
+/**
+ * Complete database table schema definition.
+ * Can be either a normal table or a shared content table.
+ */
+export type DbTableDefinition = DbNormalTableDefinition | DbSharedContentTableDefinition;
 /**
  * Permission definition for a database table.
  * NONE means the action is not allowed.

package/dist/fromRimori/EventBus.d.ts

@@ -24,8 +24,19 @@ export declare class EventBusHandler {
     private static instance;
     private debugEnabled;
     private evName;
+    private generatedIds;
+    private cleanupInterval;
     private constructor();
     static getInstance(name?: string): EventBusHandler;
+    /**
+     * Starts the interval to cleanup the generated ids.
+     */
+    private startIdCleanup;
+    /**
+     * Generates a unique id.
+     * @returns A unique id.
+     */
+    private generateUniqueId;
     private createEvent;
     /**
      * Emits an event to the event bus. Can be a new event or a response to a request.

package/dist/fromRimori/EventBus.js

@@ -13,7 +13,10 @@ export class EventBusHandler {
         this.responseResolvers = new Map();
         this.debugEnabled = false;
         this.evName = '';
+        this.generatedIds = new Map(); // Map<id, timestamp>
+        this.cleanupInterval = null;
         //private constructor
+        this.startIdCleanup();
     }
     static getInstance(name) {
         if (!EventBusHandler.instance) {
@@ -28,8 +31,40 @@ export class EventBusHandler {
         }
         return EventBusHandler.instance;
     }
+    /**
+     * Starts the interval to cleanup the generated ids.
+     */
+    startIdCleanup() {
+        this.cleanupInterval = setInterval(() => {
+            const now = Date.now();
+            const oneMinuteAgo = now - 60000; // 60 seconds in milliseconds
+            for (const [id, timestamp] of this.generatedIds.entries()) {
+                if (timestamp < oneMinuteAgo) {
+                    this.generatedIds.delete(id);
+                }
+            }
+        }, 10000); // Run every 10 seconds
+    }
+    /**
+     * Generates a unique id.
+     * @returns A unique id.
+     */
+    generateUniqueId() {
+        const now = Date.now();
+        const oneMinuteAgo = now - 60000;
+        const id = Math.floor(Math.random() * 10000000000);
+        // Check if ID was generated within the last minute
+        const existingTimestamp = this.generatedIds.get(id);
+        if (existingTimestamp && existingTimestamp > oneMinuteAgo) {
+            // ID was recently generated, generate a new one recursively
+            return this.generateUniqueId();
+        }
+        // Store the ID with current timestamp
+        this.generatedIds.set(id, now);
+        return id;
+    }
     createEvent(sender, topic, data, eventId) {
-        const generatedEventId = eventId || Math.floor(Math.random() * 10000000000);
+        const generatedEventId = eventId || this.generateUniqueId();
         return {
             eventId: generatedEventId,
             timestamp: new Date().toISOString(),
@@ -101,7 +136,7 @@ export class EventBusHandler {
             if (!this.listeners.has(topic)) {
                 this.listeners.set(topic, new Set());
             }
-            const id = Math.floor(Math.random() * 10000000000);
+            const id = this.generateUniqueId();
             // To prevent infinite loops and processing the same eventId multiple times
             const blackListedEventIds = [];
             const eventHandler = (data) => {

package/dist/fromRimori/PluginTypes.d.ts

@@ -32,15 +32,22 @@ export interface MenuEntry {
     action_key: string;
     text: string;
     iconUrl?: string;
+    args?: Record<string, unknown>;
 }
 export type MainPanelAction = {
     plugin_id: string;
     action_key: string;
 } & Record<string, string>;
+export type SidebarAction = {
+    text: string;
+    action: string;
+    args?: Record<string, unknown>;
+};
 export interface ContextMenuAction {
     text: string;
     plugin_id: string;
     action_key: string;
+    args?: Record<string, unknown>;
 }
 /**
  * Rimori plugin structure representing the complete configuration
@@ -79,7 +86,7 @@ export interface RimoriPluginConfig<T extends object = object> {
     /**
      * Context menu actions that the plugin registers to appear in right-click menus throughout the application.
      */
-    context_menu_actions: Omit<MenuEntry, 'plugin_id'>[];
+    context_menu_actions: Omit<MenuEntry, 'plugin_id' | 'args'>[];
     /**
      * Documentation paths for different types of plugin documentation.
      */
@@ -150,6 +157,8 @@ interface ToolParameter {
     enum?: string[];
     /** Whether the parameter is optional */
     optional?: boolean;
+    /** Whether the parameter is an array */
+    isArray?: boolean;
 }
 /**
  * Union type defining all possible parameter types for LLM tools.

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export { setupWorker } from './worker/WorkerSetup';
 export { AudioController } from './controller/AudioController';
 export { Translator } from './controller/TranslationController';
 export type { TOptions } from 'i18next';
-export type { SharedContent, SharedContentObjectRequest } from './controller/SharedContentController';
+export type { SharedContent, BasicSharedContent } from './plugin/module/SharedContentController';
 export type { Exercise } from './plugin/module/ExerciseModule';
 export type { UserInfo, Language, UserRole } from './controller/SettingsController';
 export type { Message, ToolInvocation } from './controller/AIController';

package/dist/plugin/RimoriClient.d.ts

@@ -1,4 +1,4 @@
-import { SharedContent, SharedContentFilter, SharedContentObjectRequest } from '../controller/SharedContentController';
+import { SharedContentController } from './module/SharedContentController';
 import { PluginModule } from './module/PluginModule';
 import { DbModule } from './module/DbModule';
 import { EventModule } from './module/EventModule';
@@ -6,8 +6,7 @@ import { AIModule } from './module/AIModule';
 import { ExerciseModule } from './module/ExerciseModule';
 export declare class RimoriClient {
     private static instance;
-    private pluginController;
-    private sharedContentController;
+    sharedContent: SharedContentController;
     db: DbModule;
     event: EventModule;
     plugin: PluginModule;
@@ -15,97 +14,11 @@ export declare class RimoriClient {
     exercise: ExerciseModule;
     private rimoriInfo;
     private constructor();
+    static getInstance(pluginId?: string): Promise<RimoriClient>;
     navigation: {
         toDashboard: () => void;
     };
-    /**
-     * Get a query parameter value that was passed via MessageChannel
-     * @param key The query parameter key
-     * @deprecated Use the plugin.applicationMode and plugin.theme properties instead
-     * @returns The query parameter value or null if not found
-     */
-    getQueryParam(key: string): string | null;
-    static getInstance(pluginId?: string): Promise<RimoriClient>;
     runtime: {
         fetchBackend: (url: string, options: RequestInit) => Promise<Response>;
     };
-    community: {
-        /**
-         * Shared content is a way to share completable content with other users using this plugin.
-         * Typical examples are assignments, exercises, stories, etc.
-         * Users generate new shared content items and others can complete the content too.
-         */
-        sharedContent: {
-            /**
-             * Get one dedicated shared content item by id. It does not matter if it is completed or not.
-             * @param contentType The type of shared content to get. E.g. assignments, exercises, etc.
-             * @param id The id of the shared content item.
-             * @returns The shared content item.
-             */
-            get: <T = any>(contentType: string, id: string) => Promise<SharedContent<T>>;
-            /**
-             * Get a list of shared content items.
-             * @param contentType The type of shared content to get. E.g. assignments, exercises, etc.
-             * @param filter The optional additional filter for checking new shared content based on a column and value. This is useful if the aditional information stored on the shared content is used to further narrow down the kind of shared content wanted to be received. E.g. only adjective grammar exercises.
-             * @param limit The optional limit for the number of results.
-             * @returns The list of shared content items.
-             */
-            getList: <T = any>(contentType: string, filter?: SharedContentFilter, limit?: number) => Promise<SharedContent<T>[]>;
-            /**
-             * Get new shared content.
-             * @param contentType The type of shared content to fetch. E.g. assignments, exercises, etc.
-             * @param generatorInstructions The instructions for the creation of new shared content. The object will automatically be extended with a tool property with a topic and keywords property to let a new unique topic be generated.
-             * @param filter The optional additional filter for checking new shared content based on a column and value. This is useful if the aditional information stored on the shared content is used to further narrow down the kind of shared content wanted to be received. E.g. only adjective grammar exercises.
-             * @param options An optional object with options for the new shared content.
-             * @param options.privateTopic An optional flag to indicate if the topic should be private and only be visible to the user. This is useful if the topic is not meant to be shared with other users. Like for personal topics or if the content is based on the personal study goal.
-             * @param options.skipDbSave An optional flag to indicate if the new shared content should not be saved to the database. This is useful if the new shared content is not meant to be saved to the database.
-             * @param options.alwaysGenerateNew An optional flag to indicate if the new shared content should always be generated even if there is already a content with the same filter. This is useful if the new shared content is not meant to be saved to the database.
-             * @param options.excludeIds An optional list of ids to exclude from the selection. This is useful if the new shared content is not meant to be saved to the database.
-             * @returns The new shared content.
-             */
-            getNew: <T = any>(contentType: string, generatorInstructions: SharedContentObjectRequest, filter?: SharedContentFilter, options?: {
-                privateTopic?: boolean;
-                skipDbSave?: boolean;
-                alwaysGenerateNew?: boolean;
-                excludeIds?: string[];
-            }) => Promise<SharedContent<T>>;
-            /**
-             * Create a new shared content item.
-             * @param content The content to create.
-             * @returns The new shared content item.
-             */
-            create: <T = any>(content: Omit<SharedContent<T>, "id">) => Promise<SharedContent<T>>;
-            /**
-             * Update a shared content item.
-             * @param id The id of the shared content item to update.
-             * @param content The content to update.
-             * @returns The updated shared content item.
-             */
-            update: <T = any>(id: string, content: Partial<SharedContent<T>>) => Promise<SharedContent<T>>;
-            /**
-             * Complete a shared content item.
-             * @param contentType The type of shared content to complete. E.g. assignments, exercises, etc.
-             * @param assignmentId The id of the shared content item to complete.
-             */
-            complete: (contentType: string, assignmentId: string) => Promise<void>;
-            /**
-             /**
-              * Update the state of a shared content item for a specific user.
-              * Useful for marking content as completed, ongoing, hidden, liked, disliked, or bookmarked.
-              */
-            updateState: (params: {
-                contentType: string;
-                id: string;
-                state?: "completed" | "ongoing" | "hidden";
-                reaction?: "liked" | "disliked" | null;
-                bookmarked?: boolean;
-            }) => Promise<void>;
-            /**
-             * Remove a shared content item.
-             * @param id The id of the shared content item to remove.
-             * @returns The removed shared content item.
-             */
-            remove: (id: string) => Promise<SharedContent<any>>;
-        };
-    };
 }

package/dist/plugin/RimoriClient.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { SharedContentController, } from '../controller/SharedContentController';
+import { SharedContentController } from './module/SharedContentController';
 import { RimoriCommunicationHandler } from './CommunicationHandler';
 import { Logger } from './Logger';
 import { PluginModule } from './module/PluginModule';
@@ -27,93 +27,8 @@ export class RimoriClient {
                 return fetch(this.rimoriInfo.backendUrl + url, Object.assign(Object.assign({}, options), { headers: Object.assign(Object.assign({}, options.headers), { Authorization: `Bearer ${this.rimoriInfo.token}` }) }));
             }),
         };
-        this.community = {
-            /**
-             * Shared content is a way to share completable content with other users using this plugin.
-             * Typical examples are assignments, exercises, stories, etc.
-             * Users generate new shared content items and others can complete the content too.
-             */
-            sharedContent: {
-                /**
-                 * Get one dedicated shared content item by id. It does not matter if it is completed or not.
-                 * @param contentType The type of shared content to get. E.g. assignments, exercises, etc.
-                 * @param id The id of the shared content item.
-                 * @returns The shared content item.
-                 */
-                get: (contentType, id) => __awaiter(this, void 0, void 0, function* () {
-                    return yield this.sharedContentController.getSharedContent(contentType, id);
-                }),
-                /**
-                 * Get a list of shared content items.
-                 * @param contentType The type of shared content to get. E.g. assignments, exercises, etc.
-                 * @param filter The optional additional filter for checking new shared content based on a column and value. This is useful if the aditional information stored on the shared content is used to further narrow down the kind of shared content wanted to be received. E.g. only adjective grammar exercises.
-                 * @param limit The optional limit for the number of results.
-                 * @returns The list of shared content items.
-                 */
-                getList: (contentType, filter, limit) => __awaiter(this, void 0, void 0, function* () {
-                    return yield this.sharedContentController.getSharedContentList(contentType, filter, limit);
-                }),
-                /**
-                 * Get new shared content.
-                 * @param contentType The type of shared content to fetch. E.g. assignments, exercises, etc.
-                 * @param generatorInstructions The instructions for the creation of new shared content. The object will automatically be extended with a tool property with a topic and keywords property to let a new unique topic be generated.
-                 * @param filter The optional additional filter for checking new shared content based on a column and value. This is useful if the aditional information stored on the shared content is used to further narrow down the kind of shared content wanted to be received. E.g. only adjective grammar exercises.
-                 * @param options An optional object with options for the new shared content.
-                 * @param options.privateTopic An optional flag to indicate if the topic should be private and only be visible to the user. This is useful if the topic is not meant to be shared with other users. Like for personal topics or if the content is based on the personal study goal.
-                 * @param options.skipDbSave An optional flag to indicate if the new shared content should not be saved to the database. This is useful if the new shared content is not meant to be saved to the database.
-                 * @param options.alwaysGenerateNew An optional flag to indicate if the new shared content should always be generated even if there is already a content with the same filter. This is useful if the new shared content is not meant to be saved to the database.
-                 * @param options.excludeIds An optional list of ids to exclude from the selection. This is useful if the new shared content is not meant to be saved to the database.
-                 * @returns The new shared content.
-                 */
-                getNew: (contentType, generatorInstructions, filter, options) => __awaiter(this, void 0, void 0, function* () {
-                    return yield this.sharedContentController.getNewSharedContent(contentType, generatorInstructions, filter, options);
-                }),
-                /**
-                 * Create a new shared content item.
-                 * @param content The content to create.
-                 * @returns The new shared content item.
-                 */
-                create: (content) => __awaiter(this, void 0, void 0, function* () {
-                    return yield this.sharedContentController.createSharedContent(content);
-                }),
-                /**
-                 * Update a shared content item.
-                 * @param id The id of the shared content item to update.
-                 * @param content The content to update.
-                 * @returns The updated shared content item.
-                 */
-                update: (id, content) => __awaiter(this, void 0, void 0, function* () {
-                    return yield this.sharedContentController.updateSharedContent(id, content);
-                }),
-                /**
-                 * Complete a shared content item.
-                 * @param contentType The type of shared content to complete. E.g. assignments, exercises, etc.
-                 * @param assignmentId The id of the shared content item to complete.
-                 */
-                complete: (contentType, assignmentId) => __awaiter(this, void 0, void 0, function* () {
-                    return yield this.sharedContentController.completeSharedContent(contentType, assignmentId);
-                }),
-                /**
-                 /**
-                  * Update the state of a shared content item for a specific user.
-                  * Useful for marking content as completed, ongoing, hidden, liked, disliked, or bookmarked.
-                  */
-                updateState: (params) => __awaiter(this, void 0, void 0, function* () {
-                    return yield this.sharedContentController.updateSharedContentState(params);
-                }),
-                /**
-                 * Remove a shared content item.
-                 * @param id The id of the shared content item to remove.
-                 * @returns The removed shared content item.
-                 */
-                remove: (id) => __awaiter(this, void 0, void 0, function* () {
-                    return yield this.sharedContentController.removeSharedContent(id);
-                }),
-            },
-        };
         this.rimoriInfo = info;
-        this.pluginController = controller;
-        this.sharedContentController = new SharedContentController(supabase, this);
+        this.sharedContent = new SharedContentController(supabase, this);
         this.ai = new AIModule(controller, info);
         this.event = new EventModule(info.pluginId);
         this.db = new DbModule(supabase, controller, info);
@@ -127,26 +42,12 @@ export class RimoriClient {
             Logger.getInstance(this);
         }
     }
-    /**
-     * Get a query parameter value that was passed via MessageChannel
-     * @param key The query parameter key
-     * @deprecated Use the plugin.applicationMode and plugin.theme properties instead
-     * @returns The query parameter value or null if not found
-     */
-    getQueryParam(key) {
-        return this.pluginController.getQueryParam(key);
-    }
     static getInstance(pluginId) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!RimoriClient.instance) {
                 if (!pluginId)
                     throw new Error('Plugin ID is required');
                 const controller = new RimoriCommunicationHandler(pluginId, false);
-                if (typeof WorkerGlobalScope === 'undefined') {
-                    // In standalone mode, use URL fallback. In iframe mode, theme will be set after MessageChannel init
-                    // setTheme();
-                    // await StandaloneClient.initListeners(pluginId);
-                }
                 const client = yield controller.getClient();
                 RimoriClient.instance = new RimoriClient(controller, client.supabase, client.info);
             }
@@ -154,5 +55,3 @@ export class RimoriClient {
         });
     }
 }
-// test 123456
-// console.log('test 1234567890');

package/dist/plugin/module/EventModule.d.ts

@@ -1,4 +1,4 @@
-import { MainPanelAction } from '../../fromRimori/PluginTypes';
+import { MainPanelAction, SidebarAction } from '../../fromRimori/PluginTypes';
 import { AccomplishmentPayload } from '../../controller/AccomplishmentController';
 import { EventBusMessage, EventHandler, EventPayload, EventListener } from '../../fromRimori/EventBus';
 /**
@@ -64,7 +64,7 @@ export declare class EventModule {
      * @param actionKey The key of the action to trigger.
      * @param text Optional text to be used for the action like for example text that the translator would look up.
      */
-    emitSidebarAction(pluginId: string, actionKey: string, text?: string): void;
+    emitSidebarAction(pluginId: string, actionKey: string, text?: string, args?: Record<string, unknown>): void;
     /**
      * Subscribe to main panel actions triggered by the user from the dashboard.
      * @param callback Handler function that receives the action data when a matching action is triggered.
@@ -95,5 +95,5 @@ export declare class EventModule {
      * @param actionsToListen Optional filter to listen only to specific action keys. If empty or not provided, all actions will trigger the callback.
      * @returns An EventListener object with an `off()` method for cleanup.
      */
-    onSidePanelAction(callback: (data: MainPanelAction) => void, actionsToListen?: string | string[]): EventListener;
+    onSidePanelAction(callback: (data: SidebarAction) => void, actionsToListen?: string | string[]): EventListener;
 }

package/dist/plugin/module/EventModule.js

@@ -102,8 +102,8 @@ export class EventModule {
      * @param actionKey The key of the action to trigger.
      * @param text Optional text to be used for the action like for example text that the translator would look up.
      */
-    emitSidebarAction(pluginId, actionKey, text) {
-        this.emit('global.sidebar.triggerAction', { plugin_id: pluginId, action_key: actionKey, text });
+    emitSidebarAction(pluginId, actionKey, text, args) {
+        this.emit('global.sidebar.triggerAction', { plugin_id: pluginId, action_key: actionKey, text, args });
     }
     /**
      * Subscribe to main panel actions triggered by the user from the dashboard.

package/dist/plugin/module/SharedContentController.d.ts

@@ -0,0 +1,142 @@
+import { ObjectTool } from '../../fromRimori/PluginTypes';
+import { SupabaseClient } from '../CommunicationHandler';
+import { RimoriClient } from '../RimoriClient';
+export type SharedContent<T> = BasicSharedContent & T;
+export interface BasicSharedContent {
+    id: string;
+    title: string;
+    keywords: string[];
+    verified: boolean;
+    created_by: string;
+    created_at: string;
+    guild_id: string | null;
+    lang_id: string | null;
+}
+export interface SharedContentCompletionState {
+    content_id: string;
+    state: 'completed' | 'ongoing' | 'hidden';
+    reaction?: 'liked' | 'disliked' | null;
+    bookmarked: boolean;
+    created_at: string;
+    updated_at: string;
+}
+export declare class SharedContentController {
+    private supabase;
+    private rimoriClient;
+    constructor(supabase: SupabaseClient, rimoriClient: RimoriClient);
+    /**
+     * Get new shared content. First searches for existing content matching filters that hasn't been completed,
+     * then falls back to AI generation if nothing suitable is found.
+     * @param params - Parameters object
+     * @param params.table - Name of the shared content table (without plugin prefix)
+     * @param params.skillType - Type of skill this content is for (grammar, reading, writing, speaking, listening, understanding)
+     * @param params.placeholders - Placeholders for instructions template for AI generation (e.g., {topicAreas: "history"})
+     * @param params.filter - Filter to find existing content:
+     *   - `exact`: Match field value exactly (e.g., {topic_category: {filterType: "exact", value: "history"}})
+     *   - `exclude`: Exclude specific field value (e.g., {difficulty: {filterType: "exclude", value: "hard"}})
+     *   - `rag`: Use semantic similarity search (e.g., {topic: {filterType: "rag", value: "japanese culture"}})
+     * @param params.customFields - Custom field values for AI-generated content (e.g., {topic_category: "history"})
+     * @param params.skipDbSave - If true, don't save generated content to database
+     * @param params.isPrivate - If true, content is guild-specific
+     * @returns Existing or newly generated shared content item
+     */
+    getNew<T>(params: {
+        table: string;
+        skillType: 'grammar' | 'reading' | 'writing' | 'speaking' | 'listening' | 'understanding';
+        placeholders?: Record<string, string>;
+        filter?: Record<string, {
+            filterType: 'rag' | 'exact' | 'exclude';
+            value: string;
+        }>;
+        customFields?: Record<string, string | number | boolean | null>;
+        tool?: ObjectTool;
+        skipDbSave?: boolean;
+        isPrivate?: boolean;
+    }): Promise<SharedContent<T>>;
+    /**
+     * Search for shared content by topic using RAG (semantic similarity).
+     * @param tableName - Name of the shared content table
+     * @param topic - Topic to search for
+     * @param limit - Maximum number of results
+     * @returns Array of similar shared content
+     */
+    searchByTopic<T>(tableName: string, topic: string, limit?: number): Promise<SharedContent<T>[]>;
+    /**
+     * Get bookmarked shared content.
+     * @param tableName - Name of the shared content table
+     * @param limit - Maximum number of results
+     * @returns Array of bookmarked content
+     */
+    getBookmarked<T>(tableName: string, limit?: number): Promise<SharedContent<T>[]>;
+    /**
+     * Get ongoing shared content.
+     * @param tableName - Name of the shared content table
+     * @param limit - Maximum number of results
+     * @returns Array of ongoing content
+     */
+    getOngoing<T>(tableName: string, limit?: number): Promise<SharedContent<T>[]>;
+    /**
+     * Get completed shared content.
+     * @param tableName - Name of the shared content table
+     * @param limit - Maximum number of results
+     * @returns Array of completed content
+     */
+    getCompleted<T>(tableName: string, limit?: number): Promise<SharedContent<T>[]>;
+    /**
+     * Mark shared content as completed.
+     * @param tableName - Name of the shared content table
+     * @param contentId - ID of the content to mark as completed
+     */
+    complete(tableName: string, contentId: string): Promise<void>;
+    /**
+     * Update the state of shared content.
+     * @param tableName - Name of the shared content table
+     * @param contentId - ID of the content
+     * @param state - New state
+     */
+    updateState(tableName: string, contentId: string, state: 'completed' | 'ongoing' | 'hidden'): Promise<void>;
+    /**
+     * Bookmark or unbookmark shared content.
+     * @param tableName - Name of the shared content table
+     * @param contentId - ID of the content
+     * @param bookmarked - Whether to bookmark or unbookmark
+     */
+    bookmark(tableName: string, contentId: string, bookmarked: boolean): Promise<void>;
+    /**
+     * React to shared content with like/dislike.
+     * @param tableName - Name of the shared content table
+     * @param contentId - ID of the content
+     * @param reaction - Reaction type or null to remove reaction
+     */
+    react(tableName: string, contentId: string, reaction: 'liked' | 'disliked' | null): Promise<void>;
+    /**
+     * Get a specific shared content item by ID.
+     * @param tableName - Name of the shared content table
+     * @param contentId - ID of the content
+     * @returns The shared content item
+     */
+    get<T = any>(tableName: string, contentId: string): Promise<SharedContent<T>>;
+    /**
+     * Create new shared content manually.
+     * @param tableName - Name of the shared content table
+     * @param content - Content to create
+     * @returns Created content
+     */
+    create<T = any>(tableName: string, content: Omit<SharedContent<T>, 'id' | 'created_at' | 'created_by'>): Promise<SharedContent<T>>;
+    /**
+     * Update existing shared content.
+     * @param tableName - Name of the shared content table
+     * @param contentId - ID of the content to update
+     * @param updates - Updates to apply
+     * @returns Updated content
+     */
+    update<T = any>(tableName: string, contentId: string, updates: Partial<SharedContent<T>>): Promise<SharedContent<T>>;
+    /**
+     * Delete shared content.
+     * @param tableName - Name of the shared content table
+     * @param contentId - ID of the content to delete
+     */
+    remove(tableName: string, contentId: string): Promise<void>;
+    private getCompletedTableName;
+    private getTableName;
+}