tiny-essentials 1.28.19 → 1.29.1

package/dist/v1/libs/plugin/TinyPlugin.d.mts

@@ -0,0 +1,753 @@
+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