import { z } from "zod";
export { z };
export * from "./types/plugin-registry-base";
export type PluginNames = string;
export type PluginApiType<T extends string> = any;
export declare enum WorkerMessageType {
    RPC_CALL = "RPC_CALL",
    HOOK_CALL = "HOOK_CALL",
    HOOK_RESULT = "HOOK_RESULT",
    HOOK_ERROR = "HOOK_ERROR",
    EVENT_EMIT = "EVENT_EMIT",
    MANIFEST = "MANIFEST",
    LOAD_SUCCESS = "LOAD_SUCCESS",
    LOAD_ERROR = "LOAD_ERROR",
    START_UP = "START_UP",
    UNLOAD = "UNLOAD"
}
export declare enum PluginPermission {
    Network = "network",
    Filesystem = "filesystem",
    Env = "env"
}
export declare enum RPCMethod {
    StorageGet = "storage:get",
    StorageSet = "storage:set",
    StorageDelete = "storage:delete",
    StorageClear = "storage:clear",
    EventsEmit = "events:emit",
    EventsOn = "events:on",
    HooksRegister = "hooks:register",
    ManagerGetPlugin = "manager:getPlugin",
    ManagerRegisterApi = "manager:registerApi",
    Log = "log",
    NetworkFetch = "network:fetch",
    PermissionCheck = "perm:check",
    ConfigGet = "config:get",
    StorageReload = "storage:reload"
}
export declare enum HookType {
    ON_RESOLVE = "onResolve",
    ON_LOAD = "onLoad",
    ON_START = "onStart"
}
export declare enum HookOrder {
    PRE = "pre",
    POST = "post"
}
export interface PluginResource {
    workers: Worker[];
    timers: {
        id: number | Timer;
        type: "timeout" | "interval";
    }[];
    eventListeners: {
        event: string;
        listener: Function;
    }[];
}
export interface HookRegistry<T> {
    filter: RegExp;
    callback: T;
    pluginName: string;
    order?: HookOrder;
}
export interface AppEvents {
    log: {
        level: "info" | "error" | "warn";
        message: string;
    };
    "plugin:updated": {
        name: string;
        version: string;
    };
    [key: string]: any;
}
export type EventCallback<T> = (payload: T) => void | Promise<void>;
export interface IPluginStorage {
    get<T>(key: string, defaultValue?: T): Promise<T | undefined>;
    set<T>(key: string, value: T): Promise<void>;
    delete(key: string): Promise<void>;
    clear(): Promise<void>;
    reload(): Promise<void>;
}
export interface Logger {
    info(msg: string, ...args: any[]): void;
    warn(msg: string, ...args: any[]): void;
    error(msg: string, ...args: any[]): void;
    debug?(msg: string, ...args: any[]): void;
    child?(context: string): Logger;
}
export interface IPluginManager {
    register(plugin: IPlugin): Promise<void>;
    registerIsolated(pluginPath: string, pluginName: string): Promise<void>;
    unregister(pluginName: string): Promise<void>;
    getPlugin(name: string): IPlugin | undefined;
    listPlugins(): string[];
    loadPluginsFromDirectory(directoryPath?: string): Promise<void>;
    disablePlugin(name: string): Promise<void>;
    enablePlugin(name: string): Promise<void>;
    reloadPlugin(name: string): Promise<void>;
    runOnResolve(args: OnResolveArgs): Promise<any>;
    runOnLoad(args: OnLoadArgs): Promise<any>;
    toBunPlugin(): any;
    enableHotReload(pluginDir: string): void;
    getWorkerFactory(): (url: string | URL, options?: BunWorkerOptions) => Worker;
    getMetrics(): any;
    getPluginStatus(): Record<string, any>;
    registerApi(pluginName: string, api: any): void;
    getPluginApi(pluginName: string): any | undefined;
    use(plugin: IPlugin): Promise<void>;
    plugin(plugin: IPlugin): Promise<void>;
    remove(pluginName: string): Promise<void>;
    emit<K extends keyof AppEvents>(eventName: K, payload: AppEvents[K]): boolean;
    on<K extends keyof AppEvents>(eventName: K & string, listener: (payload: AppEvents[K]) => void): this;
    once<K extends keyof AppEvents>(eventName: K & string, listener: (payload: AppEvents[K]) => void): this;
    off<K extends keyof AppEvents>(eventName: K & string, listener: (payload: AppEvents[K]) => void): this;
}
export interface PluginContext {
    emit<K extends keyof AppEvents>(event: K, payload: AppEvents[K]): void;
    on<K extends keyof AppEvents>(event: K, callback: EventCallback<AppEvents[K]>): void;
    events: {
        emit<K extends keyof AppEvents>(event: K, payload: AppEvents[K]): void;
        on<K extends keyof AppEvents>(event: K, callback: EventCallback<AppEvents[K]>): void;
    };
    storage: IPluginStorage;
    config: Record<string, any>;
    manager: IPluginManager;
    getPlugin<TName extends string>(name: TName): Promise<import("./types/plugin-registry-base").PluginApiType<TName> | undefined>;
    registerApi(api: any): void;
    log: Logger;
    createWorker(url: string | URL, options?: BunWorkerOptions): BunWorker;
    network: {
        fetch: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
    };
    file: (path: string) => any;
    env: Record<string, string | undefined>;
    setTimeout: (callback: (...args: any[]) => void, delay?: number, ...args: any[]) => number | Timer;
    setInterval: (callback: (...args: any[]) => void, delay?: number, ...args: any[]) => number | Timer;
    clearTimeout: (id: number | Timer) => void;
    clearInterval: (id: number | Timer) => void;
}
export interface BunWorkerOptions extends WorkerOptions {
    smol?: boolean;
    preload?: string[] | string;
    ref?: boolean;
    env?: Record<string, string>;
}
export interface BunWorker extends Worker {
    ref(): void;
    unref(): void;
}
export declare class AccessDeniedError extends Error {
    constructor(permission: string, pluginName: string);
}
export declare const BasicPluginSchema: z.ZodObject<{
    name: z.ZodString;
    version: z.ZodString;
}, z.core.$strip>;
export interface IPlugin {
    name: string;
    version: string;
    description?: string;
    author?: string;
    engines?: {
        host?: string;
    };
    configSchema?: z.ZodSchema;
    defaultConfig?: Record<string, any>;
    dependencies?: Record<string, string>;
    permissions?: PluginPermission[];
    allowedDomains?: string[];
    onLoad(context: PluginContext): Promise<void> | void;
    onStarted?: () => Promise<void> | void;
    onUnload(): Promise<void> | void;
    onReload?: (context: PluginContext) => Promise<void> | void;
    setup?: (build: PluginBuilder) => void | Promise<void>;
}
export type OnResolveArgs = {
    path: string;
    importer?: string;
    namespace?: string;
};
export type OnResolveResult = {
    path: string;
    namespace?: string;
} | undefined | null;
export type OnResolveCallback = (args: OnResolveArgs) => OnResolveResult | Promise<OnResolveResult>;
export type OnLoadArgs = {
    path: string;
    namespace?: string;
    previousContents?: string;
};
export type OnLoadResult = {
    contents: string;
    loader?: string;
} | undefined | null;
export type OnLoadCallback = (args: OnLoadArgs) => OnLoadResult | Promise<OnLoadResult>;
export interface PluginBuilder {
    onStart(callback: () => void | Promise<void>): void;
    onResolve(filter: RegExp | {
        filter: RegExp;
        namespace?: string;
    }, callback: OnResolveCallback, options?: {
        order?: HookOrder;
    }): void;
    onLoad(filter: RegExp | {
        filter: RegExp;
        namespace?: string;
    }, callback: OnLoadCallback, options?: {
        order?: HookOrder;
    }): void;
    config: Record<string, any>;
}
//# sourceMappingURL=types.d.ts.map