import TinyDebugger from '../tools/TinyDebugger.mjs';
import TinyVersion from './TinyVersion.mjs';
export type CryptoAlgorithm = AlgorithmIdentifier | RsaPssParams | EcdsaParams;
export type ImportKeyFormat = "pkcs8" | "raw" | "spki";
export type PluginIdentity = {
    /**
     * - The unique identifier of the plugin.
     */
    id: string;
    /**
     * - The list of authors of the plugin.
     */
    authors: string[];
    /**
     * - The list of categories of the plugin.
     */
    categories: string[];
    /**
     * - The list of tags of the plugin.
     */
    tags: string[];
};
/** @typedef {AlgorithmIdentifier | RsaPssParams | EcdsaParams} CryptoAlgorithm - A valid Web Crypto API algorithm identifier or parameter object. */
/**
 * @typedef {"pkcs8" | "raw" | "spki"} ImportKeyFormat - The format used when importing a cryptographic key.
 */
/**
 * @typedef {Object} PluginIdentity
 * @property {string} id - The unique identifier of the plugin.
 * @property {string[]} authors - The list of authors of the plugin.
 * @property {string[]} categories - The list of categories of the plugin.
 * @property {string[]} tags - The list of tags of the plugin.
 */
/**
 * Signs a plugin's identity using a private key.
 * This function is intended to be used by plugin authors during the build/release process.
 *
 * @param {string} pluginId - The unique identifier of the plugin.
 * @param {string[]} authors - The list of authors of the plugin.
 * @param {string[]} categories - The list of categories the plugin belongs to.
 * @param {string[]} tags - The list of tags the plugin has.
 * @param {CryptoKey} privateKey - The RSA private key used for signing.
 * @param {CryptoAlgorithm} [algorithm] - The cryptographic algorithm to use for signing.
 * @returns {Promise<ArrayBuffer>} A promise that resolves to the digital signature.
 * @throws {TypeError} If the inputs are invalid or the signing process fails.
 */
export declare function signPluginIdentity(pluginId: string, authors: string[], categories: string[], tags: string[], privateKey: CryptoKey, algorithm?: CryptoAlgorithm): Promise<ArrayBuffer>;
/**
 * Create a deterministic identity string.
 * @param {string} pluginId - The unique identifier of the plugin.
 * @param {string[]} authors - The list of authors of the plugin.
 * @param {string[]} categories - The list of categories of the plugin.
 * @param {string[]} tags - The list of tags of the plugin.
 * @returns {string} The deterministic identity string used for verification.
 */
export declare const createPluginIdChecker: (pluginId: string, authors: string[], categories: string[], tags: string[]) => string;
export type TinyPluginConstructor = {
    /**
     * - The logging configuration.
     */
    logCfg: DebuggerConstructor;
    /**
     * - A list of keys to be blacklisted.
     */
    sandboxBlacklist?: BlackListCorePartial;
    /**
     * - Configuration for identity-based engine access.
     */
    accessControl?: PluginAccessControlPartial;
};
/**
 * Validate asynchronous encryption signature using the native browser API.
 *
 * @param {PluginAccessControl} accessControl - The access control configuration used for verification.
 * @param {Set<string>} verifiedPlugins - The set of plugins that have already been verified.
 * @param {string} pluginId - The unique identifier of the plugin.
 * @param {string[]} authors - The list of authors of the plugin.
 * @param {string[]} categories - The list of categories of the plugin.
 * @param {string[]} tags - The list of tags of the plugin.
 * @param {string|BufferSource} signature - The cryptographic signature provided by the plugin.
 * @returns {Promise<boolean>} A promise that resolves to true if the signature is valid, false otherwise.
 */
export declare const verifyPluginSignature: (accessControl: PluginAccessControl, verifiedPlugins: Set<string>, pluginId: string, authors: string[], categories: string[], tags: string[], signature: string | BufferSource) => Promise<boolean>;
export type DebuggerConstructor = import('../tools/TinyDebugger.mjs').DebuggerConstructor;
export type LayerSecurityConfig = {
    /**
     * - The access control configuration for the layer.
     */
    accessControl: PluginAccessControl;
    /**
     * - Configuration for the layer's sandbox.
     */
    sandboxBlacklist?: BlackListCorePartial;
};
/** @typedef {import('../tools/TinyDebugger.mjs').DebuggerConstructor} DebuggerConstructor - The constructor function for a debugger instance. */
/**
 * @typedef {Object} LayerSecurityConfig
 * @property {PluginAccessControl} accessControl - The access control configuration for the layer.
 * @property {BlackListCorePartial} [sandboxBlacklist] - Configuration for the layer's sandbox.
 */
/**
 * Represents the isolated runtime environment or state container for a plugin.
 * It manages the 'ready' state and provides a secondary security layer
 * mirroring the TinyPluginCore security ecosystem.
 */
declare class TinyPluginLayer extends TinyDebugger {
    #private;
    /**
     * Gets whether the layer is initialized and ready.
     * @returns {boolean} True if the layer is ready, false otherwise.
     */
    get isReady(): boolean;
    /**
     * Gets the current layer access control whitelist.
     * @returns {BwListProtected} The current layer access control whitelist.
     */
    get accessControlWhitelist(): BwListProtected;
    /**
     * Gets the current layer access control blacklist.
     * @returns {BwListProtected} The current layer access control blacklist.
     */
    get accessControlBlacklist(): BwListProtected;
    /**
     * Gets the current layer access control mode.
     * @returns {PluginAccessControlMode} The current layer access control mode.
     */
    get accessControlMode(): PluginAccessControlMode;
    /**
     * Initializes a new instance of the TinyPluginLayer class.
     * @param {TinyPluginConstructor} [ops] - The configuration options for the constructor.
     */
    constructor(ops?: TinyPluginConstructor);
    /**
     * Internal method to initialize the layer state.
     * @template {TinyPlugin<any, any, any, any, any>} Plugin - The TinyPlugin template.
     * @template {any[]} Args - The type of arguments passed to the callback.
     * @param {Plugin} plugin - The TinyPlugin instance.
     * @param {(...args: Args) => void} [callback] - An optional callback function to execute during initialization.
     * @param {Args} args - The arguments to be passed to the callback.
     * @returns {this} The current instance of the TinyPluginLayer.
     * @throws {Error} If the layer has already been initialized.
     */
    _startLayer<Plugin extends TinyPlugin<any, any, any, any, any>, Args extends any[]>(plugin: Plugin, callback?: (...args: Args) => void, ...args: Args): this;
    /**
     * Validates if a plugin is permitted to access the layer based on identity.
     * @param {string} pluginId - The unique identifier of the plugin.
     * @param {readonly string[]} authors - The list of authors of the plugin.
     * @param {readonly string[]} categories - The list of categories of the plugin.
     * @param {readonly string[]} tags - The list of tags of the plugin.
     * @returns {boolean} True if access is granted, false otherwise.
     */
    canAccessLayer(pluginId: string, authors: readonly string[], categories: readonly string[], tags: readonly string[]): boolean;
    /**
     * Validates an asynchronous signature for the layer's scope.
     * @param {string} pluginId - The unique identifier.
     * @param {string[]} authors - The authors list.
     * @param {string[]} categories - The categories list.
     * @param {string[]} tags - The tags list.
     * @param {string} signature - The cryptographic signature.
     * @returns {Promise<boolean>} A promise that resolves to true if the signature is valid, false otherwise.
     */
    verifyPluginSignature(pluginId: string, authors: string[], categories: string[], tags: string[], signature: string): Promise<boolean>;
    /**
     * Creates a secure proxy to restrict plugin access to the host.
     * This ensures that even if the layer is passed to external entities,
     * its internal state and lifecycle methods remain protected.
     * @param {BlackListValue[]} allowedSets - The list of keys allowed to be set.
     * @param {BlackListValue[]} allowedGets - The list of keys allowed to be accessed.
     * @returns {this} The proxied instance of the layer.
     */
    _createSandbox(allowedSets: BlackListValue[], allowedGets: BlackListValue[]): this;
}
export type BlackListValue = string | symbol;
export type BlackListCore = {
    /**
     * - The set of restricted keys for getting.
     */
    get: Set<BlackListValue>;
    /**
     * - The set of restricted keys for setting.
     */
    set: Set<BlackListValue>;
};
export type BlackListCorePartial = {
    /**
     * - A list of restricted keys for getting.
     */
    get?: BlackListValue[];
    /**
     * - A list of restricted keys for setting.
     */
    set?: BlackListValue[];
};
export type BlackListCoreProtected = {
    /**
     * - A read-only array of restricted keys for getting.
     */
    get: Readonly<BlackListValue[]>;
    /**
     * - A read-only array of restricted keys for setting.
     */
    set: Readonly<BlackListValue[]>;
};
export type BwList = {
    /**
     * - A set of restricted plugin IDs.
     */
    ids: Set<BlackListValue>;
    /**
     * - A set of restricted author names.
     */
    authors: Set<BlackListValue>;
    /**
     * - A set of restricted plugin categories.
     */
    categories: Set<BlackListValue>;
    /**
     * - A set of restricted plugin tags.
     */
    tags: Set<BlackListValue>;
};
export type BwListArray = {
    /**
     * - An array of restricted plugin IDs.
     */
    ids: BlackListValue[];
    /**
     * - An array of restricted author names.
     */
    authors: BlackListValue[];
    /**
     * - An array of restricted plugin categories.
     */
    categories: BlackListValue[];
    /**
     * - An array of restricted plugin tags.
     */
    tags: BlackListValue[];
};
export type BwListProtected = {
    /**
     * - A read-only array of restricted plugin IDs.
     */
    ids: Readonly<BlackListValue[]>;
    /**
     * - A read-only array of restricted author names.
     */
    authors: Readonly<BlackListValue[]>;
    /**
     * - A read-only array of restricted plugin categories.
     */
    categories: Readonly<BlackListValue[]>;
    /**
     * - A read-only array of restricted plugin tags.
     */
    tags: Readonly<BlackListValue[]>;
};
export type PluginAccessControlMode = 'none' | 'whitelist' | 'blacklist' | 'cryptographic';
export type PluginAccessControlPartial = {
    /**
     * - The operational mode for engine access control.
     */
    mode: PluginAccessControlMode;
    /**
     * - The whitelist configuration.
     */
    whitelist?: BwListArray;
    /**
     * - The blacklist configuration.
     */
    blacklist?: BwListArray;
    /**
     * - The public key used for cryptographic verification.
     */
    publicKey?: string;
    /**
     * - The algorithm used for signature verification.
     */
    cryptoAlgorithm?: CryptoAlgorithm;
    /**
     * - The algorithm used for importing the public key.
     */
    importAlgorithm?: CryptoAlgorithm;
    /**
     * - The format of the key being imported.
     */
    importKeyFormat?: ImportKeyFormat;
};
export type PluginAccessControl = {
    /**
     * - The operational mode for engine access control.
     */
    mode: PluginAccessControlMode;
    /**
     * - The whitelist configuration.
     */
    whitelist: BwList;
    /**
     * - The blacklist configuration.
     */
    blacklist: BwList;
    /**
     * - The public key used for cryptographic verification.
     */
    publicKey: string | null;
    /**
     * - The algorithm used for signature verification.
     */
    cryptoAlgorithm: CryptoAlgorithm;
    /**
     * - The algorithm used for importing the public key.
     */
    importAlgorithm: CryptoAlgorithm;
    /**
     * - The format of the key being imported.
     */
    importKeyFormat: ImportKeyFormat;
};
/** @typedef {string|symbol} BlackListValue - The type of value that can be stored in a blacklist (either a string or a symbol). */
/**
 * @typedef {Object} BlackListCore
 * @property {Set<BlackListValue>} get - The set of restricted keys for getting.
 * @property {Set<BlackListValue>} set - The set of restricted keys for setting.
 */
/**
 * @typedef {Object} BlackListCorePartial
 * @property {BlackListValue[]} [get] - A list of restricted keys for getting.
 * @property {BlackListValue[]} [set] - A list of restricted keys for setting.
 */
/**
 * @typedef {Object} BlackListCoreProtected
 * @property {Readonly<BlackListValue[]>} get - A read-only array of restricted keys for getting.
 * @property {Readonly<BlackListValue[]>} set - A read-only array of restricted keys for setting.
 */
/**
 * @typedef {Object} BwList
 * @property {Set<BlackListValue>} ids - A set of restricted plugin IDs.
 * @property {Set<BlackListValue>} authors - A set of restricted author names.
 * @property {Set<BlackListValue>} categories - A set of restricted plugin categories.
 * @property {Set<BlackListValue>} tags - A set of restricted plugin tags.
 */
/**
 * @typedef {Object} BwListArray
 * @property {BlackListValue[]} ids - An array of restricted plugin IDs.
 * @property {BlackListValue[]} authors - An array of restricted author names.
 * @property {BlackListValue[]} categories - An array of restricted plugin categories.
 * @property {BlackListValue[]} tags - An array of restricted plugin tags.
 */
/**
 * @typedef {Object} BwListProtected
 * @property {Readonly<BlackListValue[]>} ids - A read-only array of restricted plugin IDs.
 * @property {Readonly<BlackListValue[]>} authors - A read-only array of restricted author names.
 * @property {Readonly<BlackListValue[]>} categories - A read-only array of restricted plugin categories.
 * @property {Readonly<BlackListValue[]>} tags - A read-only array of restricted plugin tags.
 */
/**
 * The operational mode for engine access control.
 * @typedef {'none' | 'whitelist' | 'blacklist' | 'cryptographic'} PluginAccessControlMode
 */
/**
 * @typedef {Object} PluginAccessControlPartial
 * @property {PluginAccessControlMode} mode - The operational mode for engine access control.
 * @property {BwListArray} [whitelist] - The whitelist configuration.
 * @property {BwListArray} [blacklist] - The blacklist configuration.
 * @property {string} [publicKey] - The public key used for cryptographic verification.
 * @property {CryptoAlgorithm} [cryptoAlgorithm] - The algorithm used for signature verification.
 * @property {CryptoAlgorithm} [importAlgorithm] - The algorithm used for importing the public key.
 * @property {ImportKeyFormat} [importKeyFormat] - The format of the key being imported.
 */
/**
 * @typedef {Object} PluginAccessControl
 * @property {PluginAccessControlMode} mode - The operational mode for engine access control.
 * @property {BwList} whitelist - The whitelist configuration.
 * @property {BwList} blacklist - The blacklist configuration.
 * @property {string|null} publicKey - The public key used for cryptographic verification.
 * @property {CryptoAlgorithm} cryptoAlgorithm - The algorithm used for signature verification.
 * @property {CryptoAlgorithm} importAlgorithm - The algorithm used for importing the public key.
 * @property {ImportKeyFormat} importKeyFormat - The format of the key being imported.
 */
/**
 * The core engine class responsible for managing the plugin lifecycle and registry.
 * It extends TinyDebugger to provide debugging capabilities alongside plugin management.
 */
declare class TinyPluginCore extends TinyDebugger {
    #private;
    /** @returns {typeof TinyPluginLayer} */
    static get TinyPluginLayer(): typeof TinyPluginLayer;
    /**
     * Gets the event name used when all plugins are destroyed.
     * @returns {string} The event name.
     */
    static get pluginsDestroyEventName(): string;
    /**
     * Sets the event name used when all plugins are destroyed.
     * @param {string} value - The new event name.
     * @throws {TypeError} If the value is not a string.
     */
    static set pluginsDestroyEventName(value: string);
    /**
     * Gets the blacklist of restricted keys for the engine.
     * @returns {BlackListCoreProtected} A read-only array of restricted keys.
     */
    get sandboxBlacklist(): BlackListCoreProtected;
    /**
     * Returns a plain object representation of the registered plugins.
     * This converts the internal Map into a standard object, providing a snapshot
     * of the plugins for easier external access.
     * @returns {Record<string, TinyPlugin<this, TinyPluginLayer, string, string, any[]>>} An object where keys are plugin names and values are the plugin instances.
     */
    get plugins(): Record<string, TinyPlugin<this, TinyPluginLayer, string, string, any[]>>;
    /**
     * Gets the total number of registered plugins in the engine.
     * @returns {number} The total number of registered plugins in the engine.
     */
    get pluginsSize(): number;
    /**
     * Gets the current engine access control whitelist.
     * @returns {BwListProtected} The current engine access control whitelist.
     */
    get accessControlWhitelist(): BwListProtected;
    /**
     * Gets the current engine access control blacklist.
     * @returns {BwListProtected} The current engine access control blacklist.
     */
    get accessControlBlacklist(): BwListProtected;
    /**
     * Gets the current engine access control mode.
     * @returns {PluginAccessControlMode} The current engine access control mode.
     */
    get accessControlMode(): PluginAccessControlMode;
    /**
     * Initializes a new instance of the TinyPluginCore class.
     * @param {TinyPluginConstructor} ops - The configuration options.
     */
    constructor(ops: TinyPluginConstructor);
    /**
     * Validates if a plugin is permitted to access the engine's properties based on identity.
     * @param {string} pluginId - The unique identifier of the plugin.
     * @param {readonly string[]} authors - The list of authors of the plugin.
     * @param {readonly string[]} categories - The list of categories of the plugin.
     * @param {readonly string[]} tags - The list of tags of the plugin.
     * @returns {boolean} True if access is granted, false otherwise.
     */
    canAccessEngine(pluginId: string, authors: readonly string[], categories: readonly string[], tags: readonly string[]): boolean;
    /**
     * Validate asynchronous encryption signature using the native browser API.
     * @param {string} pluginId - The unique identifier of the plugin.
     * @param {string[]} authors - The list of authors of the plugin.
     * @param {string[]} categories - The list of categories of the plugin.
     * @param {string[]} tags - The list of tags of the plugin.
     * @param {string} signature - The cryptographic signature.
     * @returns {Promise<boolean>} A promise that resolves to true if the signature is valid, false otherwise.
     */
    verifyPluginSignature(pluginId: string, authors: string[], categories: string[], tags: string[], signature: string): Promise<boolean>;
    /**
     * Registers a plugin instance into the engine's internal plugin registry.
     *
     * @param {TinyPlugin<this, TinyPluginLayer, string, string, any[]>} plugin - The plugin instance to be registered.
     * @throws {TypeError} If the provided plugin is not an instance of TinyPlugin.
     * @throws {Error} If the plugin is denied access to the core based on current access control rules.
     */
    _addPlugin(plugin: TinyPlugin<this, TinyPluginLayer, string, string, any[]>): void;
    /**
     * Installs a new plugin into the engine and starts its lifecycle.
     *
     * @template {TinyPluginLayer} Layer - The type of the plugin layer.
     * @template {string} Id - The type of the plugin ID.
     * @template {string} Version - The type of the plugin version.
     * @template {any[]} Options - The type of the configuration options.
     * @param {TinyPluginInstaller<this, Layer, Id, Version, Options>} plugin - The plugin instance to be registered.
     * @param {Options} options - Configuration options for the plugin.
     * @returns {TinyPlugin<this, Layer, Id, Version, Options>} The newly installed plugin instance.
     */
    installPlugin<Layer extends TinyPluginLayer, Id extends string, Version extends string, Options extends any[]>(plugin: TinyPluginInstaller<this, Layer, Id, Version, Options>, ...options: Options): TinyPlugin<this, Layer, Id, Version, Options>;
    /**
     * Checks if a specific plugin is already registered in the engine's internal registry.
     * @param {TinyPlugin<this, TinyPluginLayer, string, string, any[]>|string} plugin - The plugin instance or ID to check.
     * @returns {boolean} True if the plugin is registered, false otherwise.
     */
    hasPlugin(plugin: TinyPlugin<this, TinyPluginLayer, string, string, any[]> | string): boolean;
    /**
     * Retrieves a plugin instance by its unique identifier.
     * @param {string} key - The unique identifier of the plugin.
     * @returns {TinyPlugin<this, TinyPluginLayer, string, string, any[]>|undefined} The plugin instance if found, otherwise undefined.
     */
    getPlugin(key: string): TinyPlugin<this, TinyPluginLayer, string, string, any[]> | undefined;
    /**
     * Retrieves a plugin instance by its unique identifier with security enforcement.
     * This method checks the target plugin's identity against the engine's
     * access control rules (whitelist/blacklist/cryptographic).
     *
     * @template {any} ExternalPlugin - The external plugin trying to get the target plugin.
     * @param {string} targetId - The unique identifier of the target plugin.
     * @param {ExternalPlugin} externalPlugin - The external plugin trying to get the target plugin.
     * @returns {TinyPlugin<this, TinyPluginLayer, string, string, any[]>|undefined} The plugin instance if access is granted, otherwise undefined.
     */
    _getPlugin<ExternalPlugin extends any>(targetId: string, externalPlugin: ExternalPlugin): TinyPlugin<this, TinyPluginLayer, string, string, any[]> | undefined;
    /**
     * Destroys all registered plugins and emits the destruction event.
     */
    destroyPlugins(): void;
}
export type TinyPluginInstaller<Engine extends TinyPluginCore, Layer extends TinyPluginLayer, IdString extends string, VersionString extends string, Options extends any[]> = (plugin: TinyPlugin<Engine, Layer, IdString, VersionString, Options>, ...options: Options) => Layer;
/**
 * A function used to install a plugin into the engine.
 * This function is responsible for the actual initialization logic of the plugin,
 * setting up its layer and validating its configuration.
 *
 * @template {TinyPluginCore} Engine - The type of the engine instance.
 * @template {TinyPluginLayer} Layer - The type of the layer returned by the installer.
 * @template {string} IdString - The type of the plugin's unique identifier.
 * @template {string} VersionString - The type of the plugin's version.
 * @template {any[]} Options - The type of the plugin's configuration options.
 *
 * @typedef { (plugin: TinyPlugin<Engine, Layer, IdString, VersionString, Options>, ...options: Options) => Layer } TinyPluginInstaller - The plugin instance being initialized.
 */
/**
 * Represents a plugin instance designed to be integrated into a main engine.
 * It encapsulates the plugin's identity (id and version), its connection to the engine,
 * its installation logic, and any associated configuration options.
 *
 * @template {TinyPluginCore} Engine - The type of the engine.
 * @template {TinyPluginLayer} Layer - The type of the plugin layer.
 * @template {string} IdString - The type of the plugin's unique identifier.
 * @template {string} VersionString - The type of the plugin's version.
 * @template {any[]} Options - The type of the plugin's configuration options.
 */
declare class TinyPlugin<Engine extends TinyPluginCore, Layer extends TinyPluginLayer, IdString extends string, VersionString extends string, Options extends any[]> extends TinyDebugger {
    #private;
    /**
     * Gets the logging configuration for the TinyPlugin class.
     * @returns {DebuggerConstructor} The logging configuration constructor.
     */
    static get logCfg(): DebuggerConstructor;
    /**
     * Sets the logging configuration for the TinyPlugin class.
     * @param {DebuggerConstructor} value - The new logging configuration.
     */
    static set logCfg(value: DebuggerConstructor);
    /**
     * Installs a new plugin into a engine and starts its lifecycle.
     * @template {TinyPluginCore} ExternalEngine - The type of the engine.
     * @template {TinyPluginLayer} ExternalLayer - The type of the plugin layer.
     * @template {string} ExternalIdString - The type of the plugin ID.
     * @template {string} ExternalVersionString - The type of the plugin version.
     * @template {any[]} ExternalOptions - The type of the plugin's configuration options.
     * @param {ExternalEngine} engine - The main instance connected to plugin.
     * @param {TinyPluginInstaller<ExternalEngine, ExternalLayer, ExternalIdString, ExternalVersionString, ExternalOptions>} plugin - The plugin instance to be registered.
     * @param {ExternalOptions} options - Configuration options for the plugin.
     * @returns {TinyPlugin<ExternalEngine, ExternalLayer, ExternalIdString, ExternalVersionString, ExternalOptions>} - The plugin instance.
     * @throws {TypeError} If the provided engine is not an instance of TinyPluginCore.
     */
    static _addModuleToCore<ExternalEngine extends TinyPluginCore, ExternalLayer extends TinyPluginLayer, ExternalIdString extends string, ExternalVersionString extends string, ExternalOptions extends any[]>(engine: ExternalEngine, plugin: TinyPluginInstaller<ExternalEngine, ExternalLayer, ExternalIdString, ExternalVersionString, ExternalOptions>, ...options: ExternalOptions): TinyPlugin<ExternalEngine, ExternalLayer, ExternalIdString, ExternalVersionString, ExternalOptions>;
    /**
     * Gets whether the plugin has been destroyed.
     * @returns {boolean} True if the plugin has been destroyed, false otherwise.
     */
    get isDestroyed(): boolean;
    /**
     * Gets the plugins object from the engine.
     * @returns {string[]} The plugins object from the engine.
     */
    get plugins(): string[];
    /**
     * Gets the total number of plugins in the engine.
     * @returns {number} The total number of plugins in the engine.
     */
    get pluginsSize(): number;
    /**
     * Retrieves the plugin instance associated with the given ID from the engine.
     * @param {string} id - The unique identifier of the plugin.
     * @returns {TinyPlugin<Engine, TinyPluginLayer, string, string, any[]>|undefined} The plugin instance if found, otherwise undefined.
     */
    getPlugin(id: string): TinyPlugin<Engine, TinyPluginLayer, string, string, any[]> | undefined;
    /**
     * Checks if the specified plugin or ID is registered in the engine.
     * @param {TinyPlugin<Engine, TinyPluginLayer, string, string, any[]>|string} plugin - The plugin instance or ID to check.
     * @returns {boolean} True if the plugin is registered, false otherwise.
     */
    hasPlugin(plugin: TinyPlugin<Engine, TinyPluginLayer, string, string, any[]> | string): boolean;
    /**
     * Gets the readiness status of the plugin.
     * @returns {boolean} True if the plugin is ready, false otherwise.
     */
    get isReady(): boolean;
    /**
     * Gets the unique identifier of the plugin.
     * @returns {IdString} The plugin id.
     */
    get id(): IdString;
    /**
     * Sets the unique identifier for the plugin.
     * @param {IdString} value - The new unique identifier for the plugin.
     * @throws {Error} If the id is already set.
     * @throws {TypeError} If the value is not a string or is empty.
     */
    set id(value: IdString);
    /**
     * Gets the description of the plugin.
     * @returns {string} The plugin description.
     */
    get description(): string;
    /**
     * Sets the description for the plugin.
     * @param {string} value - The new description for the plugin.
     * @throws {Error} If the description is already set.
     * @throws {TypeError} If the value is not a string or is empty.
     */
    set description(value: string);
    /**
     * Gets the list of authors for the plugin.
     * @returns {readonly string[]} The plugin authors.
     * @throws {Error} If the plugin authors are not set.
     */
    get authors(): readonly string[];
    /**
     * Sets the list of authors for the plugin.
     * @param {string[]} value - The new list of authors for the plugin.
     * @throws {Error} If the authors are already set.
     * @throws {TypeError} If the value is not an array of non-empty strings or is empty.
     */
    set authors(value: string[]);
    /**
     * Gets the list of contributors to the plugin.
     * @returns {readonly string[]} The plugin contributors.
     * @throws {Error} If the plugin contributors are not set.
     */
    get contributors(): readonly string[];
    /**
     * Sets the list of contributors for the plugin.
     * @param {string[]} value - The new list of contributors for the plugin.
     * @throws {Error} If the contributors are already set.
     * @throws {TypeError} If the value is not an array of non-empty strings or is empty.
     */
    set contributors(value: string[]);
    /**
     * Gets the categories of the plugin.
     * @returns {readonly string[]} The plugin categories.
     * @throws {Error} If the plugin categories are not set.
     */
    get categories(): readonly string[];
    /**
     * Sets the categories for the plugin.
     * @param {string[]} value - The new list of the plugin categories.
     * @throws {Error} If the categories are already set.
     * @throws {TypeError} If the value is not an array of non-empty strings or is empty.
     */
    set categories(value: string[]);
    /**
     * Gets the tags of the plugin.
     * @returns {readonly string[]} The plugin tags.
     * @throws {Error} If the plugin tags are not set.
     */
    get tags(): readonly string[];
    /**
     * Sets the tags for the plugin.
     * @param {string[]} value - The new list of the plugin tags.
     * @throws {Error} If the tags are already set.
     * @throws {TypeError} If the value is not an array of non-empty strings or is empty.
     */
    set tags(value: string[]);
    /**
     * Gets the list of keys allowed to be set.
     * @returns {BlackListValue[]} The list of allowed keys for setting.
     */
    get allowedSets(): BlackListValue[];
    /**
     * Sets the list of keys allowed to be modified by the plugin.
     * @param {BlackListValue[]} value - The array of keys to be added to the allowed set.
     * @throws {Error} If the tags are already set.
     * @throws {TypeError} If the value is not an array of non-empty strings or is empty.
     */
    set allowedSets(value: BlackListValue[]);
    /**
     * Gets the list of keys allowed to be accessed.
     * @returns {BlackListValue[]} The list of allowed keys for getting.
     */
    get allowedGets(): BlackListValue[];
    /**
     * Sets the list of keys allowed to be accessed by the plugin.
     * @param {BlackListValue[]} value - The array of keys to be added to the allowed get list.
     * @throws {Error} If the tags are already set.
     * @throws {TypeError} If the value is not an array of non-empty strings or is empty.
     */
    set allowedGets(value: BlackListValue[]);
    /**
     * Gets the version of the plugin as a string.
     * @returns {VersionString} The plugin version.
     * @throws {Error} If the plugin version is not set.
     */
    get version(): VersionString;
    /**
     * Sets the version of the plugin.
     * @param {VersionString} value - The new version string for the plugin.
     * @throws {Error} If the version is already set.
     * @throws {TypeError} If the value is not a string or is empty.
     */
    set version(value: VersionString);
    /**
     * Retrieves the current version of the plugin as a TinyVersion instance.
     * @returns {TinyVersion<VersionString>} The TinyVersion instance representing the plugin's version.
     * @throws {Error} If the plugin version is not set.
     */
    get tinyVersion(): TinyVersion<VersionString>;
    /**
     * Gets the plugin's layer instance.
     * @returns {Layer} The proxied plugin layer.
     */
    get layer(): Layer;
    /**
     * Gets the engine instance associated with this plugin.
     * The engine is proxied to prevent unauthorized access to internal methods.
     * @returns {Engine} The engine instance.
     * @throws {Error} If the plugin is denied access to the engine by the access control rules.
     */
    get engine(): Engine;
    /**
     * Gets the configuration options of the plugin.
     * @returns {Options} The configuration options of the plugin.
     */
    get options(): Options;
    /**
     * Gets the blacklist of restricted keys from the engine.
     * This is accessible within the plugin's sandbox for inspection.
     * @returns {BlackListCoreProtected} The blacklist from the engine.
     */
    get engineBlacklist(): BlackListCoreProtected;
    /**
     * Initializes a new instance of TinyPlugin.
     * @param {Object} config - The configuration object.
     * @param {Engine} config.engine - The engine instance.
     * @param {DebuggerConstructor} config.logCfg - The logging configuration.
     * @param {TinyPluginInstaller<Engine, Layer, IdString, VersionString, Options>} config.installer - The installer function.
     * @param {Options} ops - Additional configuration options.
     */
    constructor({ engine, logCfg, installer }: {
        engine: Engine;
        logCfg: DebuggerConstructor;
        installer: TinyPluginInstaller<Engine, Layer, IdString, VersionString, Options>;
    }, ...ops: Options);
    /**
     * Starts the plugin lifecycle by calling the installer.
     * @throws {Error} If the plugin is already ready.
     * @throws {Error} If the initialization fails.
     */
    _startPlugin(): void;
    /**
     * Destroys the plugin instance.
     */
    destroy(): void;
}
export { TinyPlugin, TinyPluginCore, TinyPluginLayer };
//# sourceMappingURL=TinyPlugin.d.mts.map