@objectstack/spec 2.0.4 → 2.0.6

package/dist/index-C8xlxqpA.d.ts

@@ -1,767 +0,0 @@
-import { Q as QueryAST, a as FieldSchema } from './field.zod-DuaF0Lcl.js';
-import { D as DataEngineQueryOptions, a as DataEngineInsertOptions, b as DataEngineUpdateOptions, c as DataEngineDeleteOptions, d as DataEngineCountOptions, e as DataEngineAggregateOptions, f as DataEngineRequest, g as DriverOptions, O as ObjectSchema } from './driver.zod-BJHWEbwG.js';
-import { z } from 'zod';
-
-/**
- * Logger Contract
- *
- * Defines the interface for logging in ObjectStack.
- * Compatible with both browser console and structured logging systems.
- */
-interface Logger {
-    /**
-     * Log a debug message
-     * @param message - The message to log
-     * @param meta - Optional metadata to include
-     */
-    debug(message: string, meta?: Record<string, any>): void;
-    /**
-     * Log an informational message
-     * @param message - The message to log
-     * @param meta - Optional metadata to include
-     */
-    info(message: string, meta?: Record<string, any>): void;
-    /**
-     * Log a warning message
-     * @param message - The message to log
-     * @param meta - Optional metadata to include
-     */
-    warn(message: string, meta?: Record<string, any>): void;
-    /**
-     * Log an error message
-     * @param message - The message to log
-     * @param error - Optional error object
-     * @param meta - Optional metadata to include
-     */
-    error(message: string, error?: Error, meta?: Record<string, any>): void;
-    /**
-     * Log a fatal error message
-     * @param message - The message to log
-     * @param error - Optional error object
-     * @param meta - Optional metadata to include
-     */
-    fatal?(message: string, error?: Error, meta?: Record<string, any>): void;
-    /**
-     * Create a child logger with additional context
-     * @param context - Context to add to all logs from this child
-     */
-    child?(context: Record<string, any>): Logger;
-    /**
-     * Set trace context for distributed tracing
-     * @param traceId - Trace identifier
-     * @param spanId - Span identifier
-     */
-    withTrace?(traceId: string, spanId?: string): Logger;
-    /**
-     * Compatibility method for console.log usage
-     * @param message - The message to log
-     * @param args - Additional arguments
-     */
-    log?(message: string, ...args: any[]): void;
-    /**
-     * Cleanup resources (close file streams, etc.)
-     * Should be called when the logger is no longer needed
-     */
-    destroy?(): Promise<void>;
-}
-
-/**
- * IDataEngine - Standard Data Engine Interface
- *
- * Abstract interface for data persistence capabilities.
- * Following the Dependency Inversion Principle - plugins depend on this interface,
- * not on concrete database implementations.
- *
- * Aligned with 'src/data/data-engine.zod.ts' in @objectstack/spec.
- */
-interface IDataEngine {
-    find(objectName: string, query?: DataEngineQueryOptions): Promise<any[]>;
-    findOne(objectName: string, query?: DataEngineQueryOptions): Promise<any>;
-    insert(objectName: string, data: any | any[], options?: DataEngineInsertOptions): Promise<any>;
-    update(objectName: string, data: any, options?: DataEngineUpdateOptions): Promise<any>;
-    delete(objectName: string, options?: DataEngineDeleteOptions): Promise<any>;
-    count(objectName: string, query?: DataEngineCountOptions): Promise<number>;
-    aggregate(objectName: string, query: DataEngineAggregateOptions): Promise<any[]>;
-    /**
-     * Vector Search (AI/RAG)
-     */
-    vectorFind?(objectName: string, vector: number[], options?: {
-        filter?: any;
-        limit?: number;
-        select?: string[];
-        threshold?: number;
-    }): Promise<any[]>;
-    /**
-     * Batch Operations (Transactional)
-     */
-    batch?(requests: DataEngineRequest[], options?: {
-        transaction?: boolean;
-    }): Promise<any[]>;
-    /**
-     * Execute raw command (Escape hatch)
-     */
-    execute?(command: any, options?: Record<string, any>): Promise<any>;
-}
-interface DriverInterface {
-    name: string;
-    version: string;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    find(object: string, query: QueryAST, options?: DriverOptions): Promise<any[]>;
-    findOne(object: string, query: QueryAST, options?: DriverOptions): Promise<any>;
-    create(object: string, data: any, options?: DriverOptions): Promise<any>;
-    update(object: string, id: any, data: any, options?: DriverOptions): Promise<any>;
-    delete(object: string, id: any, options?: DriverOptions): Promise<any>;
-    /**
-     * Bulk & Batch Operations
-     */
-    bulkCreate?(object: string, data: any[], options?: DriverOptions): Promise<any>;
-    updateMany?(object: string, query: QueryAST, data: any, options?: DriverOptions): Promise<any>;
-    deleteMany?(object: string, query: QueryAST, options?: DriverOptions): Promise<any>;
-    count?(object: string, query: QueryAST, options?: DriverOptions): Promise<number>;
-    /**
-     * Raw Execution
-     */
-    execute?(command: any, params?: any, options?: DriverOptions): Promise<any>;
-}
-
-/**
- * IHttpServer - Standard HTTP Server Interface
- *
- * Abstract interface for HTTP server capabilities.
- * This allows plugins to interact with HTTP servers without knowing
- * the underlying implementation (Express, Fastify, Hono, etc.).
- *
- * Follows Dependency Inversion Principle - plugins depend on this interface,
- * not on concrete HTTP framework implementations.
- */
-/**
- * Generic HTTP Request type
- * Abstraction over framework-specific request objects
- */
-interface IHttpRequest {
-    /** Request path parameters */
-    params: Record<string, string>;
-    /** Request query parameters */
-    query: Record<string, string | string[]>;
-    /** Request body */
-    body?: any;
-    /** Request headers */
-    headers: Record<string, string | string[]>;
-    /** HTTP method */
-    method: string;
-    /** Request path */
-    path: string;
-}
-/**
- * Generic HTTP Response type
- * Abstraction over framework-specific response objects
- */
-interface IHttpResponse {
-    /**
-     * Send a JSON response
-     * @param data - Data to send
-     */
-    json(data: any): void | Promise<void>;
-    /**
-     * Send a text/html response
-     * @param data - Data to send
-     */
-    send(data: string): void | Promise<void>;
-    /**
-     * Set HTTP status code
-     * @param code - HTTP status code
-     */
-    status(code: number): IHttpResponse;
-    /**
-     * Set response header
-     * @param name - Header name
-     * @param value - Header value (string or array of strings for multi-value headers)
-     */
-    header(name: string, value: string | string[]): IHttpResponse;
-}
-/**
- * Route handler function
- */
-type RouteHandler = (req: IHttpRequest, res: IHttpResponse) => void | Promise<void>;
-/**
- * Middleware function
- */
-type Middleware = (req: IHttpRequest, res: IHttpResponse, next: () => void | Promise<void>) => void | Promise<void>;
-/**
- * IHttpServer - HTTP Server capability interface
- *
- * Defines the contract for HTTP server implementations.
- * Concrete implementations (Express, Fastify, Hono) should implement this interface.
- */
-interface IHttpServer {
-    /**
-     * Register a GET route handler
-     * @param path - Route path (e.g., '/api/users/:id')
-     * @param handler - Route handler function
-     */
-    get(path: string, handler: RouteHandler): void;
-    /**
-     * Register a POST route handler
-     * @param path - Route path
-     * @param handler - Route handler function
-     */
-    post(path: string, handler: RouteHandler): void;
-    /**
-     * Register a PUT route handler
-     * @param path - Route path
-     * @param handler - Route handler function
-     */
-    put(path: string, handler: RouteHandler): void;
-    /**
-     * Register a DELETE route handler
-     * @param path - Route path
-     * @param handler - Route handler function
-     */
-    delete(path: string, handler: RouteHandler): void;
-    /**
-     * Register a PATCH route handler
-     * @param path - Route path
-     * @param handler - Route handler function
-     */
-    patch(path: string, handler: RouteHandler): void;
-    /**
-     * Register middleware
-     * @param path - Optional path to apply middleware to (if omitted, applies globally)
-     * @param handler - Middleware function
-     */
-    use(path: string | Middleware, handler?: Middleware): void;
-    /**
-     * Start the HTTP server
-     * @param port - Port number to listen on
-     * @returns Promise that resolves when server is ready
-     */
-    listen(port: number): Promise<void>;
-    /**
-     * Stop the HTTP server
-     * @returns Promise that resolves when server is stopped
-     */
-    close?(): Promise<void>;
-}
-
-/**
- * IServiceRegistry - Service Registry Interface
- *
- * Abstract interface for managing service registration and lookup.
- * This provides a single source of truth for all services in the system.
- *
- * Following the Dependency Inversion Principle - both kernel implementations
- * and plugins depend on this interface, not on concrete implementations.
- */
-interface IServiceRegistry {
-    /**
-     * Register a service with a unique name
-     * @param name - Unique service identifier
-     * @param service - The service instance to register
-     * @throws Error if service name is already registered
-     */
-    register<T>(name: string, service: T): void;
-    /**
-     * Get a registered service by name (synchronous)
-     * @param name - Service identifier
-     * @returns The registered service
-     * @throws Error if service is not found
-     */
-    get<T>(name: string): T;
-    /**
-     * Get a registered service by name (asynchronous)
-     * Useful for lazy-loaded or async-initialized services
-     * @param name - Service identifier
-     * @param scopeId - Optional scope identifier for scoped services
-     * @returns Promise resolving to the registered service
-     * @throws Error if service is not found
-     */
-    getAsync<T>(name: string, scopeId?: string): Promise<T>;
-    /**
-     * Check if a service is registered
-     * @param name - Service identifier
-     * @returns True if service is registered, false otherwise
-     */
-    has(name: string): boolean;
-    /**
-     * Unregister a service
-     * @param name - Service identifier
-     * @returns True if service was unregistered, false if it wasn't registered
-     */
-    unregister(name: string): boolean;
-    /**
-     * Get all registered service names
-     * @returns Array of service names
-     */
-    getServiceNames?(): string[];
-    /**
-     * Clear all registered services
-     * Useful for cleanup in tests or during shutdown
-     */
-    clear?(): void;
-}
-/**
- * BasicServiceRegistry - Simple synchronous implementation
- * Used by ObjectKernel for basic service management
- */
-interface IBasicServiceRegistry extends IServiceRegistry {
-}
-/**
- * AdvancedServiceRegistry - Enhanced implementation with additional features
- * Used by ObjectKernel for advanced service management
- */
-interface IAdvancedServiceRegistry extends IServiceRegistry {
-    /**
-     * Register a factory function that creates services on-demand
-     * @param name - Service identifier
-     * @param factory - Factory function that creates the service
-     * @param singleton - If true, factory is called once and result is cached
-     */
-    registerFactory?<T>(name: string, factory: () => T | Promise<T>, singleton?: boolean): void;
-    /**
-     * Register a scoped service (per-request, per-session, etc.)
-     * @param name - Service identifier
-     * @param factory - Factory function that creates the service
-     * @param scopeType - Type of scope ('request', 'session', 'transaction', etc.)
-     */
-    registerScoped?<T>(name: string, factory: (scopeId: string) => T | Promise<T>, scopeType: string): void;
-    /**
-     * Create a new scope for scoped services
-     * @param scopeType - Type of scope
-     * @returns Scope identifier
-     */
-    createScope?(scopeType: string): string;
-    /**
-     * Dispose a scope and cleanup scoped services
-     * @param scopeId - Scope identifier
-     */
-    disposeScope?(scopeId: string): Promise<void>;
-}
-
-/**
- * IPluginValidator - Plugin Validator Interface
- *
- * Abstract interface for validating plugins before registration and startup.
- * Extracted from PluginLoader to follow Single Responsibility Principle.
- */
-/**
- * Validation result for a plugin
- */
-interface ValidationResult {
-    /**
-     * Whether the plugin passed validation
-     */
-    valid: boolean;
-    /**
-     * Validation errors (if any)
-     */
-    errors?: Array<{
-        field: string;
-        message: string;
-        code?: string;
-    }>;
-    /**
-     * Validation warnings (non-fatal issues)
-     */
-    warnings?: Array<{
-        field: string;
-        message: string;
-        code?: string;
-    }>;
-}
-/**
- * Plugin metadata for validation
- */
-interface Plugin {
-    /**
-     * Unique plugin identifier
-     */
-    name: string;
-    /**
-     * Plugin version (semver)
-     */
-    version?: string;
-    /**
-     * Plugin dependencies
-     */
-    dependencies?: string[];
-    /**
-     * Plugin initialization function
-     */
-    init?: (context: any) => void | Promise<void>;
-    /**
-     * Plugin startup function
-     */
-    start?: (context: any) => void | Promise<void>;
-    /**
-     * Plugin destruction function
-     */
-    destroy?: (context: any) => void | Promise<void>;
-    /**
-     * Plugin signature for verification (optional)
-     */
-    signature?: string;
-    /**
-     * Additional plugin metadata
-     */
-    [key: string]: any;
-}
-/**
- * IPluginValidator - Plugin validation interface
- */
-interface IPluginValidator {
-    /**
-     * Validate a plugin object structure
-     * @param plugin - Plugin to validate
-     * @returns Validation result
-     */
-    validate(plugin: unknown): ValidationResult;
-    /**
-     * Validate plugin version format (semver)
-     * @param version - Version string to validate
-     * @returns True if version is valid, false otherwise
-     */
-    validateVersion(version: string): boolean;
-    /**
-     * Validate plugin cryptographic signature (optional)
-     * Used for plugin security verification
-     * @param plugin - Plugin to validate
-     * @returns Promise resolving to true if signature is valid
-     */
-    validateSignature?(plugin: Plugin): Promise<boolean>;
-    /**
-     * Validate plugin dependencies are satisfied
-     * @param plugin - Plugin to validate
-     * @param registry - Map of already registered plugins
-     * @throws Error if dependencies are not satisfied
-     */
-    validateDependencies(plugin: Plugin, registry: Map<string, Plugin>): void;
-    /**
-     * Validate plugin has required lifecycle methods
-     * @param plugin - Plugin to validate
-     * @returns True if plugin has valid lifecycle methods
-     */
-    validateLifecycle?(plugin: Plugin): boolean;
-}
-
-/**
- * IStartupOrchestrator - Startup Orchestrator Interface
- *
- * Abstract interface for orchestrating plugin startup with advanced features:
- * - Timeout handling
- * - Rollback on failure
- * - Health checks
- * - Startup metrics
- *
- * Extracted from PluginLoader to follow Single Responsibility Principle.
- */
-/**
- * Startup options for orchestration
- */
-interface StartupOptions {
-    /**
-     * Maximum time (ms) to wait for each plugin to start
-     * @default 30000 (30 seconds)
-     */
-    timeout?: number;
-    /**
-     * Whether to rollback (destroy) already-started plugins on failure
-     * @default true
-     */
-    rollbackOnFailure?: boolean;
-    /**
-     * Whether to run health checks after startup
-     * @default false
-     */
-    healthCheck?: boolean;
-    /**
-     * Whether to run plugins in parallel (if dependencies allow)
-     * @default false (sequential startup)
-     */
-    parallel?: boolean;
-    /**
-     * Custom context to pass to plugin lifecycle methods
-     */
-    context?: any;
-}
-/**
- * Plugin startup result
- */
-interface PluginStartupResult {
-    /**
-     * Plugin that was started
-     */
-    plugin: Plugin;
-    /**
-     * Whether startup was successful
-     */
-    success: boolean;
-    /**
-     * Time taken to start (milliseconds)
-     */
-    duration: number;
-    /**
-     * Error if startup failed
-     */
-    error?: Error;
-    /**
-     * Health status after startup (if healthCheck enabled)
-     */
-    health?: HealthStatus;
-}
-/**
- * Health status for a plugin
- */
-interface HealthStatus {
-    /**
-     * Whether the plugin is healthy
-     */
-    healthy: boolean;
-    /**
-     * Health check timestamp
-     */
-    timestamp: number;
-    /**
-     * Optional health details
-     */
-    details?: Record<string, any>;
-    /**
-     * Optional error message if unhealthy
-     */
-    message?: string;
-}
-/**
- * IStartupOrchestrator - Plugin startup orchestration interface
- */
-interface IStartupOrchestrator {
-    /**
-     * Orchestrate startup of multiple plugins
-     * Handles timeout, rollback, and health checks
-     * @param plugins - Array of plugins to start (in dependency order)
-     * @param options - Startup options
-     * @returns Promise resolving to startup results for each plugin
-     */
-    orchestrateStartup(plugins: Plugin[], options: StartupOptions): Promise<PluginStartupResult[]>;
-    /**
-     * Rollback (destroy) a set of plugins
-     * Used when startup fails and rollback is enabled
-     * @param startedPlugins - Plugins that were successfully started
-     * @returns Promise that resolves when rollback is complete
-     */
-    rollback(startedPlugins: Plugin[]): Promise<void>;
-    /**
-     * Check health of a single plugin
-     * @param plugin - Plugin to check
-     * @returns Promise resolving to health status
-     */
-    checkHealth(plugin: Plugin): Promise<HealthStatus>;
-    /**
-     * Wait for a plugin to start with timeout
-     * @param plugin - Plugin to start
-     * @param context - Plugin context
-     * @param timeoutMs - Maximum time to wait (milliseconds)
-     * @returns Promise resolving when plugin starts or rejecting on timeout
-     */
-    startWithTimeout?(plugin: Plugin, context: any, timeoutMs: number): Promise<void>;
-}
-
-/**
- * IPluginLifecycleEvents - Typed Plugin Lifecycle Events
- *
- * Type-safe event definitions for plugin and kernel lifecycle.
- * Provides strong typing for event emitters and listeners.
- *
- * This replaces the generic Map<string, any[]> approach with typed events.
- */
-/**
- * Plugin lifecycle event types and their payloads
- */
-interface IPluginLifecycleEvents {
-    /**
-     * Emitted when kernel is ready (all plugins initialized)
-     * Payload: []
-     */
-    'kernel:ready': [];
-    /**
-     * Emitted when kernel is shutting down
-     * Payload: []
-     */
-    'kernel:shutdown': [];
-    /**
-     * Emitted before kernel initialization starts
-     * Payload: []
-     */
-    'kernel:before-init': [];
-    /**
-     * Emitted after kernel initialization completes
-     * Payload: [duration: number (milliseconds)]
-     */
-    'kernel:after-init': [duration: number];
-    /**
-     * Emitted when a plugin is registered
-     * Payload: [pluginName: string]
-     */
-    'plugin:registered': [pluginName: string];
-    /**
-     * Emitted before a plugin's init method is called
-     * Payload: [pluginName: string]
-     */
-    'plugin:before-init': [pluginName: string];
-    /**
-     * Emitted when a plugin has been initialized
-     * Payload: [pluginName: string]
-     */
-    'plugin:init': [pluginName: string];
-    /**
-     * Emitted after a plugin's init method completes
-     * Payload: [pluginName: string, duration: number (milliseconds)]
-     */
-    'plugin:after-init': [pluginName: string, duration: number];
-    /**
-     * Emitted before a plugin's start method is called
-     * Payload: [pluginName: string]
-     */
-    'plugin:before-start': [pluginName: string];
-    /**
-     * Emitted when a plugin has started successfully
-     * Payload: [pluginName: string, duration: number (milliseconds)]
-     */
-    'plugin:started': [pluginName: string, duration: number];
-    /**
-     * Emitted after a plugin's start method completes
-     * Payload: [pluginName: string, duration: number (milliseconds)]
-     */
-    'plugin:after-start': [pluginName: string, duration: number];
-    /**
-     * Emitted before a plugin's destroy method is called
-     * Payload: [pluginName: string]
-     */
-    'plugin:before-destroy': [pluginName: string];
-    /**
-     * Emitted when a plugin has been destroyed
-     * Payload: [pluginName: string]
-     */
-    'plugin:destroyed': [pluginName: string];
-    /**
-     * Emitted after a plugin's destroy method completes
-     * Payload: [pluginName: string, duration: number (milliseconds)]
-     */
-    'plugin:after-destroy': [pluginName: string, duration: number];
-    /**
-     * Emitted when a plugin encounters an error
-     * Payload: [pluginName: string, error: Error, phase: 'init' | 'start' | 'destroy']
-     */
-    'plugin:error': [pluginName: string, error: Error, phase: 'init' | 'start' | 'destroy'];
-    /**
-     * Emitted when a service is registered
-     * Payload: [serviceName: string]
-     */
-    'service:registered': [serviceName: string];
-    /**
-     * Emitted when a service is unregistered
-     * Payload: [serviceName: string]
-     */
-    'service:unregistered': [serviceName: string];
-    /**
-     * Emitted when a hook is registered
-     * Payload: [hookName: string, handlerCount: number]
-     */
-    'hook:registered': [hookName: string, handlerCount: number];
-    /**
-     * Emitted when a hook is triggered
-     * Payload: [hookName: string, args: any[]]
-     */
-    'hook:triggered': [hookName: string, args: any[]];
-}
-/**
- * Type-safe event emitter interface
- * Provides compile-time type checking for event names and payloads
- */
-interface ITypedEventEmitter<Events extends Record<string, any[]>> {
-    /**
-     * Register an event listener
-     * @param event - Event name (type-checked)
-     * @param handler - Event handler (type-checked against event payload)
-     */
-    on<K extends keyof Events>(event: K, handler: (...args: Events[K]) => void | Promise<void>): void;
-    /**
-     * Unregister an event listener
-     * @param event - Event name (type-checked)
-     * @param handler - Event handler to remove
-     */
-    off<K extends keyof Events>(event: K, handler: (...args: Events[K]) => void | Promise<void>): void;
-    /**
-     * Emit an event with type-checked payload
-     * @param event - Event name (type-checked)
-     * @param args - Event payload (type-checked)
-     */
-    emit<K extends keyof Events>(event: K, ...args: Events[K]): Promise<void>;
-    /**
-     * Register a one-time event listener
-     * @param event - Event name (type-checked)
-     * @param handler - Event handler (type-checked against event payload)
-     */
-    once?<K extends keyof Events>(event: K, handler: (...args: Events[K]) => void | Promise<void>): void;
-    /**
-     * Get the number of listeners for an event
-     * @param event - Event name
-     * @returns Number of registered listeners
-     */
-    listenerCount?<K extends keyof Events>(event: K): number;
-    /**
-     * Remove all listeners for an event (or all events if not specified)
-     * @param event - Optional event name
-     */
-    removeAllListeners?<K extends keyof Events>(event?: K): void;
-}
-
-type DataField = z.infer<typeof FieldSchema>;
-type DataObject = z.infer<typeof ObjectSchema>;
-/**
- * Interface for Data Definition Language (DDL) operations.
- * Drivers should implement this to support automatic migrations.
- */
-interface ISchemaDriver {
-    createCollection(objectName: string, schema?: DataObject): Promise<void>;
-    dropCollection(objectName: string): Promise<void>;
-    addColumn(objectName: string, fieldName: string, field: DataField): Promise<void>;
-    modifyColumn(objectName: string, fieldName: string, field: DataField): Promise<void>;
-    dropColumn(objectName: string, fieldName: string): Promise<void>;
-    createIndex(objectName: string, indexName: string, fields: string[]): Promise<void>;
-    dropIndex(objectName: string, indexName: string): Promise<void>;
-    executeRaw(statement: string): Promise<any>;
-}
-
-/**
- * ObjectStack Contracts
- *
- * Core interface definitions following "Protocol First" principle.
- * All interfaces should be defined in @objectstack/spec to avoid circular dependencies.
- */
-
-type index_DriverInterface = DriverInterface;
-type index_HealthStatus = HealthStatus;
-type index_IAdvancedServiceRegistry = IAdvancedServiceRegistry;
-type index_IBasicServiceRegistry = IBasicServiceRegistry;
-type index_IDataEngine = IDataEngine;
-type index_IHttpRequest = IHttpRequest;
-type index_IHttpResponse = IHttpResponse;
-type index_IHttpServer = IHttpServer;
-type index_IPluginLifecycleEvents = IPluginLifecycleEvents;
-type index_IPluginValidator = IPluginValidator;
-type index_ISchemaDriver = ISchemaDriver;
-type index_IServiceRegistry = IServiceRegistry;
-type index_IStartupOrchestrator = IStartupOrchestrator;
-type index_ITypedEventEmitter<Events extends Record<string, any[]>> = ITypedEventEmitter<Events>;
-type index_Logger = Logger;
-type index_Middleware = Middleware;
-type index_Plugin = Plugin;
-type index_PluginStartupResult = PluginStartupResult;
-type index_RouteHandler = RouteHandler;
-type index_StartupOptions = StartupOptions;
-type index_ValidationResult = ValidationResult;
-declare namespace index {
-  export type { index_DriverInterface as DriverInterface, index_HealthStatus as HealthStatus, index_IAdvancedServiceRegistry as IAdvancedServiceRegistry, index_IBasicServiceRegistry as IBasicServiceRegistry, index_IDataEngine as IDataEngine, index_IHttpRequest as IHttpRequest, index_IHttpResponse as IHttpResponse, index_IHttpServer as IHttpServer, index_IPluginLifecycleEvents as IPluginLifecycleEvents, index_IPluginValidator as IPluginValidator, index_ISchemaDriver as ISchemaDriver, index_IServiceRegistry as IServiceRegistry, index_IStartupOrchestrator as IStartupOrchestrator, index_ITypedEventEmitter as ITypedEventEmitter, index_Logger as Logger, index_Middleware as Middleware, index_Plugin as Plugin, index_PluginStartupResult as PluginStartupResult, index_RouteHandler as RouteHandler, index_StartupOptions as StartupOptions, index_ValidationResult as ValidationResult };
-}
-
-export { type DriverInterface as D, type HealthStatus as H, type IDataEngine as I, type Logger as L, type Middleware as M, type Plugin as P, type RouteHandler as R, type StartupOptions as S, type ValidationResult as V, type IHttpRequest as a, type IHttpResponse as b, type IHttpServer as c, type IServiceRegistry as d, type IBasicServiceRegistry as e, type IAdvancedServiceRegistry as f, type IPluginValidator as g, type PluginStartupResult as h, index as i, type IStartupOrchestrator as j, type IPluginLifecycleEvents as k, type ITypedEventEmitter as l, type ISchemaDriver as m };