import 'reflect-metadata';
import { BundlePurews } from '@worktif/purews';
import { RuntimeWebContainer } from '../runtime-web.container';
/**
 * CoreBasicBundle provides the base functionality for creating and managing a container with DI (Dependency Injection)
 * and lambda runtime support. It extends `BundlePurews` to ensure core application module behavior with additional
 * support for initialization and service management.
 *
 * This class serves as an abstraction layer for managing dependency-injected containers and lambda handlers
 * in a runtime web environment. The functionalities include configuring scoped dependencies and ensuring
 * they are tied to service handlers dynamically.
 *
 * Note: This is an injectable service-via-container implementation tailored to runtime web environments.
 *
 * @class CoreBasicBundle
 * @extends BundlePurews
 */
export declare abstract class CoreBasicBundle extends BundlePurews {
    /**
     * @class Container
     *
     * @classdesc
     * The Container class represents a variable container, which can hold, retrieve, and modify values of any type.
     * It allows storing key-value pairs, similar to a dictionary or associative array, where the keys are strings
     * representing variable names and the values are the corresponding values.
     *
     * @constructor
     * Creates a new Container object.
     */
    protected container: RuntimeWebContainer;
    /**
     * Registry of bound handler methods by Lambda ID.
     *
     * This registry stores pre-bound handler methods for each Lambda function,
     * allowing direct access by Lambda ID without repeated DI resolution.
     *
     * Format: { 'serviceName.lambdaId': boundHandlerMethod }
     */
    handlers: Record<string, Function>;
    /**
     * Cache for DI container instances to avoid repeated initialization.
     *
     * This cache stores resolved DI instances by their key, ensuring that
     * the same instance is reused across multiple handler invocations.
     *
     * Format: { 'diKey': resolvedInstance }
     */
    protected diInstanceCache: Record<string, any>;
    /**
     * Cache for bound handler methods to avoid repeated binding operations.
     *
     * This cache stores the bound handler methods to ensure consistent
     * function references across multiple accesses.
     *
     * Format: { 'lambdaId': { handler: boundMethod, instance: diInstance } }
     */
    protected handlerCache: Record<string, {
        handler: Function;
        instance: any;
    }>;
    /**
     * Initializes a new instance of the class and sets up dependencies for various Lambda services,
     * including LambdaRuntimeWebHandler, LambdaRuntimeWebSeo, and LambdaRuntimeWebManifest.
     *
     * @return {void} No return value as this is a constructor. Initializes the instance and its dependencies.
     */
    constructor(support?: boolean);
    /**
     * Executes the runContainer method, which binds lambda handlers to their respective instance keys
     * if the `container.tied` object is defined. This method ensures proper binding between handlers
     * and their associated functionality during the initialization of the container.
     *
     * Performance optimization: Caches DI instances to avoid repeated resolution.
     *
     * @return {void} This method does not return a value.
     */
    protected runContainer(): void;
    /**
     * Cache DI instances to avoid repeated resolution during Lambda invocations.
     *
     * This method iterates through all resolved instances in the stack and caches them
     * for future use, ensuring that the same instance is reused across invocations.
     *
     * Performance benefit: Eliminates repeated DI resolution overhead during Lambda execution.
     */
    protected cacheDiInstances(): void;
    /**
     * Get performance metrics for caching behavior.
     *
     * This method provides insights into the caching effectiveness for monitoring
     * and optimization purposes.
     *
     * @returns Object containing cache statistics
     */
    getCacheMetrics(): {
        diInstanceCacheSize: number;
        handlerCacheSize: number;
        totalHandlers: number;
        cacheHitRatio: number;
    };
    /**
     * Clear all caches. Primarily used for testing purposes.
     *
     * Warning: This will force re-initialization of all cached instances
     * and handlers, which may impact performance.
     */
    clearCaches(): void;
}
