/**
 * Configuration Exports
 * Central export point for all configuration
 */
export { appConfig, type AppConfig } from './app';
export { default as broadcastConfig } from './broadcast';
export { cacheConfig, type CacheConfig } from './cache';
export { databaseConfig, type DatabaseConfig } from './database';
export { microservicesConfig, type MicroservicesConfig } from './microservices';
export { middlewareConfig } from './middleware';
export { notificationConfig, type NotificationConfig } from './notification';
export { queueConfig, type QueueConfig } from './queue';
export { securityConfig } from './security';
export { storageConfig, type StorageConfig } from './storage';
export { createRedisConnection } from './workers';
/**
 * Combined configuration object
 * Sealed namespace for immutability
 */
export declare const config: Readonly<{
    readonly middleware: import("./type").MiddlewareConfigType;
    readonly app: Readonly<{
        readonly name: string;
        readonly prefix: string;
        readonly environment: import("./type").StartMode;
        readonly port: number;
        readonly host: string;
        readonly isDevelopment: () => boolean;
        readonly isProduction: () => boolean;
        readonly isTesting: () => boolean;
        readonly debug: boolean;
        readonly dockerWorker: boolean;
        readonly cloudflareWorker: boolean;
        readonly worker: boolean;
        readonly timezone: string;
        readonly requestTimeout: number;
        readonly maxBodySize: number;
        readonly getSafeEnv: () => NodeJS.ProcessEnv;
        readonly detectRuntime: () => string;
    }>;
    readonly broadcast: {
        default: string;
        drivers: import("./type").BroadcastDrivers;
        getDriverName: () => string;
        getDriverConfig: (name?: string) => import("./type").KnownBroadcastDriverConfig;
    };
    readonly database: {
        default: string;
        connections: import("./type").DatabaseConnections;
        getConnection: (this: import("./type").DatabaseConfigShape) => import("./type").DatabaseConnectionConfig;
        logging: {
            enabled: boolean;
            level: string;
        };
        migrations: {
            directory: string;
            extension: string;
        };
        seeders: {
            directory: string;
        };
    };
    readonly storage: import("./type").StorageConfigRuntime & {
        getDriver: (this: import("./type").StorageConfigRuntime) => import("./type").StorageDriverConfig;
        getDriverConfig: (this: import("./type").StorageConfigRuntime, name?: string) => import("./type").StorageDriverConfig;
        temp: {
            path: string;
            maxAge: number;
        };
        uploads: {
            maxSize: string;
            allowedMimes: string;
            path: string;
        };
        backups: {
            path: string;
            driver: string;
        };
    };
    readonly notification: {
        default: string;
        drivers: import("./type").NotificationDrivers;
        providers: import("./type").NotificationProviders;
        getDriverName: () => string;
        getDriverConfig: (name?: string) => import("./type").KnownNotificationDriverConfig;
    };
    readonly security: Readonly<{
        readonly jwt: {
            readonly enabled: boolean;
            readonly secret: string;
            readonly algorithm: "HS256" | "HS512" | "RS256";
            readonly expiresIn: number;
            readonly refreshExpiresIn: string;
            readonly issuer: string;
            readonly audience: string;
        };
        readonly csrf: {
            readonly enabled: boolean;
            readonly headerName: string;
            readonly tokenName: string;
            readonly cookieName: string;
            readonly cookieHttpOnly: boolean;
            readonly cookieSecure: boolean;
            readonly cookieSameSite: "strict" | "lax" | "none";
        };
        readonly encryption: {
            readonly cipher: string;
            readonly appKey: string;
            readonly appPreviousKeys: string;
            readonly algorithm: string;
            readonly key: string;
        };
        readonly apiKey: {
            readonly enabled: boolean;
            readonly headerName: string;
            readonly secret: string;
        };
        readonly cors: {
            readonly enabled: boolean;
            readonly origins: string[];
            readonly methods: string[];
            readonly allowedHeaders: string[];
            readonly exposedHeaders: string[];
            readonly credentials: boolean;
            readonly maxAge: number;
        };
        readonly rateLimit: {
            readonly enabled: boolean;
            readonly windowMs: number;
            readonly maxRequests: number;
            readonly message: string;
        };
        readonly xss: {
            readonly enabled: boolean;
            readonly reportUri: string;
        };
        readonly helmet: {
            readonly enabled: boolean;
            readonly contentSecurityPolicy: boolean;
            readonly hsts: {
                readonly enabled: boolean;
                readonly maxAge: number;
                readonly includeSubDomains: boolean;
            };
        };
        readonly session: {
            readonly name: string;
            readonly secret: string;
            readonly expiresIn: number;
            readonly secure: boolean;
            readonly httpOnly: boolean;
            readonly sameSite: "strict" | "lax" | "none";
        };
        readonly password: {
            readonly minLength: number;
            readonly requireUppercase: boolean;
            readonly requireNumbers: boolean;
            readonly requireSpecialChars: boolean;
            readonly bcryptRounds: number;
        };
    }>;
    readonly microservices: Readonly<{
        readonly enabled: boolean;
        readonly services: string[];
        readonly discovery: {
            readonly type: "filesystem" | "consul" | "etcd";
            readonly servicesPath: string;
            readonly refreshInterval: number;
        };
        readonly registry: {
            readonly host: string;
            readonly port: number;
            readonly deregisterCriticalServiceAfter: string;
        };
        readonly auth: {
            readonly strategy: "api-key" | "jwt" | "none" | "custom";
            readonly apiKey: string;
            readonly jwtSecret: string;
        };
        readonly tracing: {
            readonly enabled: boolean;
            readonly samplingRate: number;
            readonly exportInterval: number;
            readonly jaegerEndpoint: string;
        };
        readonly database: {
            readonly isolation: "shared" | "isolated";
            readonly schema: string;
        };
        readonly healthCheck: {
            readonly enabled: boolean;
            readonly interval: number;
            readonly timeout: number;
            readonly unhealthyThreshold: number;
            readonly healthyThreshold: number;
        };
        readonly communication: {
            readonly timeout: number;
            readonly retries: number;
            readonly retryDelay: number;
            readonly circuitBreaker: {
                readonly enabled: boolean;
                readonly threshold: number;
                readonly timeout: number;
            };
        };
        readonly mesh: {
            readonly enabled: boolean;
            readonly type: "istio" | "linkerd";
            readonly namespace: string;
        };
    }>;
    readonly cache: {
        default: string;
        drivers: import("./type").CacheConfigInput["drivers"];
        getDriver: (name?: string) => import("./type").CacheDriverConfig;
        keyPrefix: string;
        ttl: number;
    };
    readonly queue: {
        default: import("./type").QueueDriverName;
        drivers: import("./type").QueueDriversConfig;
        getDriver: (driverConfig: import("./type").QueueConfigWithDrivers) => import("./type").QueueDriversConfig[import("./type").QueueDriverName];
        failed: {
            database: string;
            table: string;
        };
        processing: {
            timeout: number;
            retries: number;
            backoff: number;
            workers: number;
        };
        monitor: {
            enabled: boolean;
            basePath: string;
            middleware: ReadonlyArray<string>;
            autoRefresh: boolean;
            refreshIntervalMs: number;
        };
    };
}>;
export type Config = typeof config;
//# sourceMappingURL=index.d.ts.map