@mulutime/plugin-types/dist/plugin-system.d.ts

TypeScript types for the MuluTime plugin system

import { JSONSchema7 } from 'json-schema';
import { IntegrationType } from './integrations';
export interface PluginEventSubscription {
    eventType: string;
    handler: string;
    description?: string;
    filters?: {
        userId?: string;
        organizationId?: string;
        conditions?: Record<string, any>;
    };
    enabled?: boolean;
    priority?: number;
}
export interface PluginScheduledFunction {
    name: string;
    handler: string;
    schedule: PluginScheduleType;
    description?: string;
    timezone?: string;
    enabled?: boolean;
}
export interface PluginApiAction {
    name: string;
    handler: string;
    description: string;
    permissions: PluginPermission[];
    parameters?: JSONSchema7;
    enabled?: boolean;
}
export declare enum PluginScheduleType {
    HOURLY = "HOURLY",
    DAILY = "DAILY",
    WEEKLY = "WEEKLY",
    MONTHLY = "MONTHLY",
    CUSTOM = "CUSTOM"
}
export declare enum APIAccessScope {
    'USER' = "USER",// Access to user/organization who installed the plugin
    'PLUGIN' = "PLUGIN",// Access to the plugin's own via plugin secret key
    'WORLD' = "WORLD"
}
export interface PluginManifest {
    id: string;
    name: string;
    version: string;
    description: string;
    author: {
        name: string;
        email: string;
        url?: string;
    };
    homepage?: string;
    repository?: string;
    license: string;
    provider: string;
    type: IntegrationType[];
    tags: string[];
    category: PluginCategory;
    permissions: PluginPermission[];
    apiVersion: string;
    minSystemVersion: string;
    configSchema?: JSONSchema7;
    allowMultipleInstances?: boolean;
    main: string;
    webhooks?: string[];
    icon?: string;
    screenshots?: string[];
    pricing?: PluginPricing;
    supportUrl?: string;
    eventSubscriptions?: PluginEventSubscription[];
    scheduledFunctions?: PluginScheduledFunction[];
    apiActions?: PluginApiAction[];
}
export interface PluginPricing {
    type: 'FREE' | 'PAID' | 'FREEMIUM' | 'SUBSCRIPTION';
    price?: number;
    currency?: string;
    billingPeriod?: 'MONTHLY' | 'YEARLY' | 'ONE_TIME';
    trialDays?: number;
}
export declare enum PluginCategory {
    CALENDAR = "CALENDAR",
    COMMUNICATION = "COMMUNICATION",
    PAYMENT = "PAYMENT",
    CRM = "CRM",
    ANALYTICS = "ANALYTICS",
    PRODUCTIVITY = "PRODUCTIVITY",
    SECURITY = "SECURITY",
    OTHER = "OTHER"
}
export declare enum PluginPermission {
    READ_USER_DATA = "READ_USER_DATA",
    WRITE_USER_DATA = "WRITE_USER_DATA",
    READ_ORGANIZATION_DATA = "READ_ORGANIZATION_DATA",
    WRITE_ORGANIZATION_DATA = "WRITE_ORGANIZATION_DATA",
    EXTERNAL_API_ACCESS = "EXTERNAL_API_ACCESS",
    WEBHOOK_ACCESS = "WEBHOOK_ACCESS",
    DATABASE_ACCESS = "DATABASE_ACCESS",
    FILE_SYSTEM_ACCESS = "FILE_SYSTEM_ACCESS",
    CREATE_CALENDAR_EVENTS = "CREATE_CALENDAR_EVENTS",
    SEND_NOTIFICATIONS = "SEND_NOTIFICATIONS",
    PAYMENT_PROCESSING = "PAYMENT_PROCESSING",
    SCHEDULED_FUNCTIONS = "SCHEDULED_FUNCTIONS",
    READ_EVENT_TYPES = "READ_EVENT_TYPES",
    WRITE_EVENT_TYPES = "WRITE_EVENT_TYPES",
    READ_BOOKINGS = "READ_BOOKINGS",
    WRITE_BOOKINGS = "WRITE_BOOKINGS",
    READ_SCHEDULES = "READ_SCHEDULES",
    WRITE_SCHEDULES = "WRITE_SCHEDULES",
    READ_ORGANIZATIONS = "READ_ORGANIZATIONS",
    WRITE_ORGANIZATIONS = "WRITE_ORGANIZATIONS",
    READ_TEAMS = "READ_TEAMS",
    WRITE_TEAMS = "WRITE_TEAMS",
    TRIGGER_EVENTS = "TRIGGER_EVENTS",
    MANAGE_USERS = "MANAGE_USERS",
    READ_SETTINGS = "READ_SETTINGS",
    WRITE_SETTINGS = "WRITE_SETTINGS"
}
export interface PluginInstance {
    id: string;
    pluginId: string;
    userId?: string;
    organizationId?: string;
    status: PluginStatus;
    config: Record<string, any>;
    installedAt: string;
    updatedAt: string;
    lastUsedAt?: string;
    version: string;
    enabled: boolean;
    permissions: PluginPermission[];
    errors?: PluginInstanceError[];
    warnings?: string[];
}
export interface CalPluginInstance extends PluginInstance {
    calendarId?: string;
    externalCalendarId?: string;
}
export declare enum PluginStatus {
    INSTALLING = "INSTALLING",
    INSTALLED = "INSTALLED",
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE",
    ERROR = "ERROR",
    UPDATING = "UPDATING",
    UNINSTALLING = "UNINSTALLING"
}
export interface PluginContext {
    userId?: string;
    organizationId?: string;
    pluginId: string;
    permissions: PluginPermission[];
    config: Record<string, any>;
    logger: PluginLogger;
    storage: PluginStorage;
    api: PluginAPIClient;
    http: any;
    setConfig?: (config: Record<string, any>) => Promise<void>;
    errors: PluginErrorHandler;
    systemBaseUrl?: string;
    apiToken?: string;
}
export interface PluginLogger {
    debug(message: string, meta?: any): void;
    info(message: string, meta?: any): void;
    warn(message: string, meta?: any): void;
    error(message: string, error?: Error, meta?: any): void;
}
export interface PluginStorage {
    get<T = any>(key: string): Promise<T | null>;
    set(key: string, value: any): Promise<void>;
    delete(key: string): Promise<void>;
    list(prefix?: string): Promise<string[]>;
}
export interface PluginAPIClient {
    get(url: string, options?: RequestInit): Promise<Response>;
    post(url: string, data?: any, options?: RequestInit): Promise<Response>;
    put(url: string, data?: any, options?: RequestInit): Promise<Response>;
    delete(url: string, options?: RequestInit): Promise<Response>;
}
export interface PluginSchedule {
    type: ScheduleType;
    pattern?: string;
    interval?: number;
    hour?: number;
    minute?: number;
}
export declare enum ScheduleType {
    HOURLY = "HOURLY",// Every hour at specified minute
    DAILY = "DAILY",// Every day at specified hour:minute
    INTERVAL = "INTERVAL",// Every X minutes
    CRON = "CRON"
}
export interface PluginScheduleSubscription {
    id: string;
    pluginId: string;
    instanceId: string;
    functionName: string;
    schedule: PluginSchedule;
    enabled: boolean;
    description?: string;
    timezone: string;
    userId?: string;
    organizationId?: string;
    lastExecuted?: string;
    nextExecution?: string;
    executionCount: number;
    failureCount: number;
    createdAt: string;
    updatedAt: string;
}
export interface IntegrationPlugin {
    manifest: PluginManifest;
    onInstall?(context: PluginContext): Promise<void>;
    onUninstall?(context: PluginContext): Promise<void>;
    onUpdate?(context: PluginContext, oldVersion: string): Promise<void>;
    onActivate?(context: PluginContext): Promise<void>;
    onDeactivate?(context: PluginContext): Promise<void>;
    validateConfig?(config: Record<string, any>): Promise<ValidationResult>;
    getConfigSchema?(): JSONSchema7;
    getEventSubscriptions?(): Array<{
        eventTypes: string[];
        actionMethod: string;
        filters?: {
            userId?: string;
            organizationId?: string;
            conditions?: Record<string, any>;
        };
        enabled?: boolean;
        priority?: number;
    }>;
    getScheduledFunctions?(): Array<{
        functionName: string;
        schedule: PluginSchedule;
        enabled?: boolean;
        description?: string;
        timezone?: string;
    }>;
    handleWebhook?(context: PluginContext, payload: any): Promise<any>;
    [key: string]: any;
}
export interface ValidationResult {
    valid: boolean;
    errors?: string[];
    warnings?: string[];
}
export interface PluginRegistryEntry {
    manifest: PluginManifest;
    downloadUrl: string;
    checksum: string;
    publisherId: string;
    publishedAt: string;
    downloads: number;
    rating?: number;
    reviews?: number;
    verified: boolean;
    eventSubscriptions: PluginEventSubscription[];
    scheduledFunctions: PluginScheduledFunction[];
    apiActions: PluginApiAction[];
}
export interface PluginSearchFilters {
    category?: PluginCategory;
    type?: IntegrationType;
    verified?: boolean;
    free?: boolean;
    query?: string;
    tags?: string[];
}
export interface ActiveEventSubscription {
    id: string;
    pluginId: string;
    instanceId: string;
    eventType: string;
    handler: string;
    description?: string;
    filters?: {
        userId?: string;
        organizationId?: string;
        conditions?: Record<string, any>;
    };
    isActive: boolean;
    priority: number;
    createdAt: string;
    lastTriggered?: string;
    triggerCount: number;
}
export interface ActiveScheduledFunction {
    id: string;
    pluginId: string;
    instanceId: string;
    functionName: string;
    handler: string;
    schedule: PluginScheduleType;
    description?: string;
    timezone: string;
    isActive: boolean;
    lastExecuted?: string;
    nextExecution?: string;
    executionCount: number;
    failureCount: number;
    createdAt: string;
}
export interface ActiveApiAction {
    id: string;
    pluginId: string;
    instanceId: string;
    actionName: string;
    handler: string;
    description: string;
    permissions: PluginPermission[];
    parameters?: JSONSchema7;
    isActive: boolean;
    createdAt: string;
    lastExecuted?: string;
    executionCount: number;
}
export { IntegrationType, IntegrationProvider, UserIntegration } from './integrations';
export interface PluginErrorHandler {
    /**
     * Report a user-facing error that should be displayed in the UI
     * @param message - Error message to display to the user
     * @param type - Type of error (info, warning, error, critical)
     * @param details - Additional error details for debugging
     */
    reportUserError(message: string, type?: 'info' | 'warning' | 'error' | 'critical', details?: any): void;
    /**
     * Report a system error for logging and monitoring
     * @param error - Error object or message
     * @param context - Additional context for debugging
     */
    reportSystemError(error: Error | string, context?: any): void;
    /**
     * Clear any existing errors for this plugin instance
     */
    clearErrors(): void;
    /**
     * Get current errors for this plugin instance
     */
    getErrors(): PluginError[];
}
export interface PluginInstanceError {
    type: 'info' | 'warning' | 'error' | 'critical';
    message: string;
    details?: any;
    timestamp: string;
}
export interface PluginError {
    id: string;
    pluginId: string;
    instanceId?: string;
    userId?: string;
    organizationId?: string;
    type: 'info' | 'warning' | 'error' | 'critical';
    message: string;
    details?: any;
    timestamp: string;
    resolved: boolean;
}
//# sourceMappingURL=plugin-system.d.ts.map