@dyanet/nestjs-config-aws 1.0.1 → 1.2.0

package/dist/esm/config-aws/src/utils/validation.util.js

@@ -0,0 +1,112 @@
+import { ValidationError } from '../errors';
+/**
+ * Framework-agnostic validation utility for configuration values.
+ * Provides methods for validating configuration objects against Zod schemas.
+ */
+export class ConfigValidationUtil {
+    /**
+     * Validates a value against a Zod schema.
+     * @param schema The Zod schema to validate against
+     * @param value The value to validate
+     * @param context Optional context for error messages
+     * @returns The validated and transformed value
+     * @throws ValidationError if validation fails
+     */
+    static validate(schema, value, context) {
+        const result = schema.safeParse(value);
+        if (result.success) {
+            return result.data;
+        }
+        const errors = this.formatValidationErrors(result.error);
+        const contextMessage = context
+            ? `Configuration validation failed for ${context}`
+            : 'Configuration validation failed';
+        throw new ValidationError(contextMessage, errors);
+    }
+    /**
+     * Safely validates a value against a Zod schema without throwing.
+     * @param schema The Zod schema to validate against
+     * @param value The value to validate
+     * @returns Object with success flag and either data or error
+     */
+    static safeValidate(schema, value) {
+        const result = schema.safeParse(value);
+        if (result.success) {
+            return { success: true, data: result.data };
+        }
+        const errors = this.formatValidationErrors(result.error);
+        const validationError = new ValidationError('Configuration validation failed', errors);
+        return { success: false, error: validationError };
+    }
+    /**
+     * Formats Zod validation errors into a structured format.
+     * @param error The ZodError to format
+     * @returns Formatted error object or string
+     */
+    static formatValidationErrors(error) {
+        // If there's only one error at the root level, return just the message
+        if (error.issues.length === 1) {
+            const issue = error.issues[0];
+            if (issue && Array.isArray(issue.path) && issue.path.length === 0) {
+                return issue.message;
+            }
+        }
+        // For multiple errors or nested paths, create a structured object
+        return error.issues.reduce((errors, issue) => {
+            const path = issue.path.join('.');
+            const key = path || 'root';
+            if (!errors[key]) {
+                errors[key] = [];
+            }
+            errors[key].push({
+                message: issue.message,
+                code: issue.code,
+                path: issue.path,
+            });
+            return errors;
+        }, {});
+    }
+    /**
+     * Creates a detailed error message for configuration validation failures.
+     * @param error The ZodError to create a message for
+     * @param context Optional context for the error
+     * @returns Detailed error message string
+     */
+    static createDetailedErrorMessage(error, context) {
+        const contextPrefix = context ? `${context}: ` : '';
+        if (error.issues.length === 1) {
+            const issue = error.issues[0];
+            if (issue) {
+                const pathStr = issue.path.length > 0 ? ` at '${issue.path.join('.')}'` : '';
+                return `${contextPrefix}${issue.message}${pathStr}`;
+            }
+        }
+        const errorMessages = error.issues.map((issue) => {
+            const pathStr = issue.path.length > 0 ? ` at '${issue.path.join('.')}'` : '';
+            return `  - ${issue.message}${pathStr}`;
+        });
+        return `${contextPrefix}Multiple validation errors:\n${errorMessages.join('\n')}`;
+    }
+    /**
+     * Validates configuration with enhanced error context.
+     * @param schema The Zod schema to validate against
+     * @param value The configuration object to validate
+     * @param source The source of the configuration (e.g., 'environment', 'secrets-manager')
+     * @returns The validated configuration
+     * @throws ValidationError with enhanced context
+     */
+    static validateConfiguration(schema, value, source) {
+        try {
+            return this.validate(schema, value, `${source} configuration`);
+        }
+        catch (error) {
+            if (error instanceof ValidationError) {
+                // Enhance the error with source information
+                const enhancedMessage = `Configuration validation failed for source '${source}': ${error.message}`;
+                throw new ValidationError(enhancedMessage, error.validationErrors);
+            }
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation.util.js","sourceRoot":"","sources":["../../../../../../config-aws/src/utils/validation.util.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ZodType, ZodError, TypeOf } from 'zod';\r\nimport { ValidationError } from '../errors';\r\n\r\n/**\r\n * Framework-agnostic validation utility for configuration values.\r\n * Provides methods for validating configuration objects against Zod schemas.\r\n */\r\nexport class ConfigValidationUtil {\r\n  /**\r\n   * Validates a value against a Zod schema.\r\n   * @param schema The Zod schema to validate against\r\n   * @param value The value to validate\r\n   * @param context Optional context for error messages\r\n   * @returns The validated and transformed value\r\n   * @throws ValidationError if validation fails\r\n   */\r\n  static validate<T extends ZodType>(\r\n    schema: T,\r\n    value: unknown,\r\n    context?: string,\r\n  ): TypeOf<T> {\r\n    const result = schema.safeParse(value);\r\n\r\n    if (result.success) {\r\n      return result.data;\r\n    }\r\n\r\n    const errors = this.formatValidationErrors(result.error);\r\n    const contextMessage = context\r\n      ? `Configuration validation failed for ${context}`\r\n      : 'Configuration validation failed';\r\n\r\n    throw new ValidationError(contextMessage, errors);\r\n  }\r\n\r\n  /**\r\n   * Safely validates a value against a Zod schema without throwing.\r\n   * @param schema The Zod schema to validate against\r\n   * @param value The value to validate\r\n   * @returns Object with success flag and either data or error\r\n   */\r\n  static safeValidate<T extends ZodType>(\r\n    schema: T,\r\n    value: unknown,\r\n  ): { success: true; data: TypeOf<T> } | { success: false; error: ValidationError } {\r\n    const result = schema.safeParse(value);\r\n\r\n    if (result.success) {\r\n      return { success: true, data: result.data };\r\n    }\r\n\r\n    const errors = this.formatValidationErrors(result.error);\r\n    const validationError = new ValidationError('Configuration validation failed', errors);\r\n\r\n    return { success: false, error: validationError };\r\n  }\r\n\r\n  /**\r\n   * Formats Zod validation errors into a structured format.\r\n   * @param error The ZodError to format\r\n   * @returns Formatted error object or string\r\n   */\r\n  static formatValidationErrors(error: ZodError): unknown {\r\n    // If there's only one error at the root level, return just the message\r\n    if (error.issues.length === 1) {\r\n      const issue = error.issues[0];\r\n      if (issue && Array.isArray(issue.path) && issue.path.length === 0) {\r\n        return issue.message;\r\n      }\r\n    }\r\n\r\n    // For multiple errors or nested paths, create a structured object\r\n    return error.issues.reduce(\r\n      (errors, issue) => {\r\n        const path = issue.path.join('.');\r\n        const key = path || 'root';\r\n\r\n        if (!errors[key]) {\r\n          errors[key] = [];\r\n        }\r\n\r\n        errors[key].push({\r\n          message: issue.message,\r\n          code: issue.code,\r\n          path: issue.path,\r\n        });\r\n\r\n        return errors;\r\n      },\r\n      {} as Record<string, Array<{ message: string; code: string; path: (string | number)[] }>>,\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Creates a detailed error message for configuration validation failures.\r\n   * @param error The ZodError to create a message for\r\n   * @param context Optional context for the error\r\n   * @returns Detailed error message string\r\n   */\r\n  static createDetailedErrorMessage(error: ZodError, context?: string): string {\r\n    const contextPrefix = context ? `${context}: ` : '';\r\n\r\n    if (error.issues.length === 1) {\r\n      const issue = error.issues[0];\r\n      if (issue) {\r\n        const pathStr = issue.path.length > 0 ? ` at '${issue.path.join('.')}'` : '';\r\n        return `${contextPrefix}${issue.message}${pathStr}`;\r\n      }\r\n    }\r\n\r\n    const errorMessages = error.issues.map((issue) => {\r\n      const pathStr = issue.path.length > 0 ? ` at '${issue.path.join('.')}'` : '';\r\n      return `  - ${issue.message}${pathStr}`;\r\n    });\r\n\r\n    return `${contextPrefix}Multiple validation errors:\\n${errorMessages.join('\\n')}`;\r\n  }\r\n\r\n  /**\r\n   * Validates configuration with enhanced error context.\r\n   * @param schema The Zod schema to validate against\r\n   * @param value The configuration object to validate\r\n   * @param source The source of the configuration (e.g., 'environment', 'secrets-manager')\r\n   * @returns The validated configuration\r\n   * @throws ValidationError with enhanced context\r\n   */\r\n  static validateConfiguration<T extends ZodType>(\r\n    schema: T,\r\n    value: unknown,\r\n    source: string,\r\n  ): TypeOf<T> {\r\n    try {\r\n      return this.validate(schema, value, `${source} configuration`);\r\n    } catch (error) {\r\n      if (error instanceof ValidationError) {\r\n        // Enhance the error with source information\r\n        const enhancedMessage = `Configuration validation failed for source '${source}': ${error.message}`;\r\n        throw new ValidationError(enhancedMessage, error.validationErrors);\r\n      }\r\n      throw error;\r\n    }\r\n  }\r\n}\r\n"]}

package/dist/esm/nestjs-config-aws/src/config.module.js

@@ -0,0 +1,172 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var ConfigModule_1;
+import { Global, Module } from '@nestjs/common';
+import { EnvironmentLoader, SecretsManagerLoader, SSMParameterStoreLoader } from '@dyanet/config-aws';
+import { ConfigService } from './interfaces/config-service.interface';
+import { defaultConfigSchema } from './interfaces/default-schema.interface';
+import { ConfigServiceImpl } from './services/config.service';
+/**
+ * Token for injecting module options
+ */
+export const NEST_CONFIG_AWS_OPTIONS = 'NEST_CONFIG_AWS_OPTIONS';
+/**
+ * NestJS module for AWS-integrated configuration management.
+ * Provides global configuration service with support for environment variables,
+ * AWS Secrets Manager, and AWS Systems Manager Parameter Store.
+ */
+let ConfigModule = ConfigModule_1 = class ConfigModule {
+    /**
+     * Create a synchronous configuration module with provided options.
+     *
+     * @param options - Configuration options for the module
+     * @returns Dynamic module configuration
+     */
+    static forRoot(options = {}) {
+        const configServiceProvider = this.createConfigServiceProvider(options);
+        return {
+            module: ConfigModule_1,
+            providers: [
+                {
+                    provide: NEST_CONFIG_AWS_OPTIONS,
+                    useValue: options,
+                },
+                configServiceProvider,
+            ],
+            exports: [ConfigService],
+            global: true,
+        };
+    }
+    /**
+     * Create an asynchronous configuration module with factory-based options.
+     * Useful when configuration options depend on other services or async operations.
+     *
+     * @param options - Async configuration options with factory function
+     * @returns Dynamic module configuration
+     */
+    static forRootAsync(options) {
+        const asyncProviders = this.createAsyncProviders(options);
+        return {
+            module: ConfigModule_1,
+            imports: options.imports || [],
+            providers: [
+                ...asyncProviders,
+                this.createAsyncConfigServiceProvider(),
+            ],
+            exports: [ConfigService],
+            global: true,
+        };
+    }
+    /**
+     * Create the ConfigService provider for synchronous module registration.
+     */
+    static createConfigServiceProvider(options) {
+        return {
+            provide: ConfigService,
+            useFactory: async () => {
+                // Create loaders based on configuration
+                const loaders = this.createLoaders(options);
+                // Create ConfigService options
+                const serviceOptions = {
+                    schema: options.schema || defaultConfigSchema,
+                    loaders,
+                    validateOnLoad: !options.ignoreValidationErrors,
+                    enableLogging: true,
+                };
+                // Create and initialize the service
+                const configService = new ConfigServiceImpl(serviceOptions);
+                // Initialize configuration loading if not in sync mode
+                if (!options.loadSync) {
+                    await configService.initialize();
+                }
+                return configService;
+            },
+        };
+    }
+    /**
+     * Create providers for asynchronous module registration.
+     */
+    static createAsyncProviders(options) {
+        return [
+            {
+                provide: NEST_CONFIG_AWS_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            },
+        ];
+    }
+    /**
+     * Create the ConfigService provider for asynchronous module registration.
+     */
+    static createAsyncConfigServiceProvider() {
+        return {
+            provide: ConfigService,
+            useFactory: async (options) => {
+                // Create loaders based on configuration
+                const loaders = this.createLoaders(options);
+                // Create ConfigService options
+                const serviceOptions = {
+                    schema: options.schema || defaultConfigSchema,
+                    loaders,
+                    validateOnLoad: !options.ignoreValidationErrors,
+                    enableLogging: true,
+                };
+                // Create and initialize the service
+                const configService = new ConfigServiceImpl(serviceOptions);
+                // Initialize configuration loading if not in sync mode
+                if (!options.loadSync) {
+                    await configService.initialize();
+                }
+                return configService;
+            },
+            inject: [NEST_CONFIG_AWS_OPTIONS],
+        };
+    }
+    /**
+     * Create configuration loaders based on module options.
+     * Uses loaders from @dyanet/config-aws core package.
+     */
+    static createLoaders(options) {
+        const loaders = [];
+        // Always add environment loader first (lowest precedence)
+        loaders.push(new EnvironmentLoader({ prefix: options.envPrefix }));
+        // Add Secrets Manager loader if enabled
+        if (options.secretsManagerConfig?.enabled !== false) {
+            const secretsConfig = {
+                region: options.secretsManagerConfig?.region,
+                // Map paths to environment mapping if provided
+                environmentMapping: options.secretsManagerConfig?.paths ? {
+                    development: options.secretsManagerConfig.paths.development || 'dev',
+                    test: options.secretsManagerConfig.paths.test || 'test',
+                    production: options.secretsManagerConfig.paths.production || 'production',
+                } : undefined,
+            };
+            loaders.push(new SecretsManagerLoader(secretsConfig));
+        }
+        // Add SSM Parameter Store loader if enabled
+        if (options.ssmConfig?.enabled !== false) {
+            const ssmConfig = {
+                region: options.ssmConfig?.region,
+                withDecryption: options.ssmConfig?.decrypt,
+                // Map paths to environment mapping if provided
+                environmentMapping: options.ssmConfig?.paths ? {
+                    development: options.ssmConfig.paths.development || 'dev',
+                    test: options.ssmConfig.paths.test || 'test',
+                    production: options.ssmConfig.paths.production || 'production',
+                } : undefined,
+            };
+            loaders.push(new SSMParameterStoreLoader(ssmConfig));
+        }
+        return loaders;
+    }
+};
+ConfigModule = ConfigModule_1 = __decorate([
+    Global(),
+    Module({})
+], ConfigModule);
+export { ConfigModule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.module.js","sourceRoot":"","sources":["../../../../src/config.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { DynamicModule, Global, Module, Provider } from '@nestjs/common';\r\nimport { ConfigLoader, EnvironmentLoader, SecretsManagerLoader, SSMParameterStoreLoader } from '@dyanet/config-aws';\r\n\r\nimport { ConfigService } from './interfaces/config-service.interface';\r\nimport { NestConfigAwsModuleOptions, NestConfigAwsModuleAsyncOptions } from './interfaces/module-options.interface';\r\nimport { DefaultConfigSchema, defaultConfigSchema } from './interfaces/default-schema.interface';\r\nimport { ConfigServiceImpl, ConfigServiceOptions } from './services/config.service';\r\n\r\n/**\r\n * Token for injecting module options\r\n */\r\nexport const NEST_CONFIG_AWS_OPTIONS = 'NEST_CONFIG_AWS_OPTIONS';\r\n\r\n/**\r\n * NestJS module for AWS-integrated configuration management.\r\n * Provides global configuration service with support for environment variables,\r\n * AWS Secrets Manager, and AWS Systems Manager Parameter Store.\r\n */\r\n@Global()\r\n@Module({})\r\nexport class ConfigModule {\r\n  /**\r\n   * Create a synchronous configuration module with provided options.\r\n   * \r\n   * @param options - Configuration options for the module\r\n   * @returns Dynamic module configuration\r\n   */\r\n  static forRoot<T = DefaultConfigSchema>(\r\n    options: NestConfigAwsModuleOptions<T> = {}\r\n  ): DynamicModule {\r\n    const configServiceProvider = this.createConfigServiceProvider(options);\r\n\r\n    return {\r\n      module: ConfigModule,\r\n      providers: [\r\n        {\r\n          provide: NEST_CONFIG_AWS_OPTIONS,\r\n          useValue: options,\r\n        },\r\n        configServiceProvider,\r\n      ],\r\n      exports: [ConfigService],\r\n      global: true,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Create an asynchronous configuration module with factory-based options.\r\n   * Useful when configuration options depend on other services or async operations.\r\n   * \r\n   * @param options - Async configuration options with factory function\r\n   * @returns Dynamic module configuration\r\n   */\r\n  static forRootAsync<T = DefaultConfigSchema>(\r\n    options: NestConfigAwsModuleAsyncOptions<T>\r\n  ): DynamicModule {\r\n    const asyncProviders = this.createAsyncProviders(options);\r\n\r\n    return {\r\n      module: ConfigModule,\r\n      imports: options.imports || [],\r\n      providers: [\r\n        ...asyncProviders,\r\n        this.createAsyncConfigServiceProvider(),\r\n      ],\r\n      exports: [ConfigService],\r\n      global: true,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Create the ConfigService provider for synchronous module registration.\r\n   */\r\n  private static createConfigServiceProvider<T>(\r\n    options: NestConfigAwsModuleOptions<T>\r\n  ): Provider {\r\n    return {\r\n      provide: ConfigService,\r\n      useFactory: async (): Promise<ConfigService<T>> => {\r\n        // Create loaders based on configuration\r\n        const loaders = this.createLoaders(options);\r\n\r\n        // Create ConfigService options\r\n        const serviceOptions: ConfigServiceOptions<T> = {\r\n          schema: options.schema || (defaultConfigSchema as any),\r\n          loaders,\r\n          validateOnLoad: !options.ignoreValidationErrors,\r\n          enableLogging: true,\r\n        };\r\n\r\n        // Create and initialize the service\r\n        const configService = new ConfigServiceImpl<T>(serviceOptions);\r\n\r\n        // Initialize configuration loading if not in sync mode\r\n        if (!options.loadSync) {\r\n          await configService.initialize();\r\n        }\r\n\r\n        return configService as ConfigService<T>;\r\n      },\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Create providers for asynchronous module registration.\r\n   */\r\n  private static createAsyncProviders<T>(\r\n    options: NestConfigAwsModuleAsyncOptions<T>\r\n  ): Provider[] {\r\n    return [\r\n      {\r\n        provide: NEST_CONFIG_AWS_OPTIONS,\r\n        useFactory: options.useFactory,\r\n        inject: options.inject || [],\r\n      },\r\n    ];\r\n  }\r\n\r\n  /**\r\n   * Create the ConfigService provider for asynchronous module registration.\r\n   */\r\n  private static createAsyncConfigServiceProvider(): Provider {\r\n    return {\r\n      provide: ConfigService,\r\n      useFactory: async (options: NestConfigAwsModuleOptions): Promise<ConfigService> => {\r\n        // Create loaders based on configuration\r\n        const loaders = this.createLoaders(options);\r\n\r\n        // Create ConfigService options\r\n        const serviceOptions: ConfigServiceOptions = {\r\n          schema: options.schema || defaultConfigSchema,\r\n          loaders,\r\n          validateOnLoad: !options.ignoreValidationErrors,\r\n          enableLogging: true,\r\n        };\r\n\r\n        // Create and initialize the service\r\n        const configService = new ConfigServiceImpl(serviceOptions);\r\n\r\n        // Initialize configuration loading if not in sync mode\r\n        if (!options.loadSync) {\r\n          await configService.initialize();\r\n        }\r\n\r\n        return configService as ConfigService;\r\n      },\r\n      inject: [NEST_CONFIG_AWS_OPTIONS],\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Create configuration loaders based on module options.\r\n   * Uses loaders from @dyanet/config-aws core package.\r\n   */\r\n  private static createLoaders<T>(options: NestConfigAwsModuleOptions<T>): ConfigLoader[] {\r\n    const loaders: ConfigLoader[] = [];\r\n\r\n    // Always add environment loader first (lowest precedence)\r\n    loaders.push(new EnvironmentLoader({ prefix: options.envPrefix }));\r\n\r\n    // Add Secrets Manager loader if enabled\r\n    if (options.secretsManagerConfig?.enabled !== false) {\r\n      const secretsConfig = {\r\n        region: options.secretsManagerConfig?.region,\r\n        // Map paths to environment mapping if provided\r\n        environmentMapping: options.secretsManagerConfig?.paths ? {\r\n          development: options.secretsManagerConfig.paths.development || 'dev',\r\n          test: options.secretsManagerConfig.paths.test || 'test',\r\n          production: options.secretsManagerConfig.paths.production || 'production',\r\n        } : undefined,\r\n      };\r\n\r\n      loaders.push(new SecretsManagerLoader(secretsConfig));\r\n    }\r\n\r\n    // Add SSM Parameter Store loader if enabled\r\n    if (options.ssmConfig?.enabled !== false) {\r\n      const ssmConfig = {\r\n        region: options.ssmConfig?.region,\r\n        withDecryption: options.ssmConfig?.decrypt,\r\n        // Map paths to environment mapping if provided\r\n        environmentMapping: options.ssmConfig?.paths ? {\r\n          development: options.ssmConfig.paths.development || 'dev',\r\n          test: options.ssmConfig.paths.test || 'test',\r\n          production: options.ssmConfig.paths.production || 'production',\r\n        } : undefined,\r\n      };\r\n\r\n      loaders.push(new SSMParameterStoreLoader(ssmConfig));\r\n    }\r\n\r\n    return loaders;\r\n  }\r\n}\r\n"]}

package/dist/esm/nestjs-config-aws/src/index.js

@@ -0,0 +1,23 @@
+// Re-export all public types from @dyanet/config-aws core package
+export { 
+// Loaders
+EnvironmentLoader, EnvFileLoader, S3Loader, SecretsManagerLoader, SSMParameterStoreLoader, 
+// ConfigManager
+ConfigManager, 
+// Error classes
+ConfigurationError, ValidationError, AWSServiceError, ConfigurationLoadError, MissingConfigurationError, 
+// Utilities
+ConfigValidationUtil, EnvFileParser, } from '@dyanet/config-aws';
+// NestJS-specific exports
+export * from './config.module';
+export * from './interfaces';
+export * from './services/config.service';
+// Integration module exports for @nestjs/config compatibility
+export * from './integration';
+// Utility functions
+export { isAwsSource, isLocalSource, hasMetadata, isValidationResult, isCacheEntry } from './integration/interfaces/utility-types.interface';
+// Decorators and utility functions
+export { InjectEnhancedConfig, ConfigProperty, ConfigClass, ValidateConfig, TransformConfig, createTypeSafeConfigFactory } from './integration/interfaces/nestjs-config-compatibility.interface';
+// Explicit exports for better discoverability
+export { NestConfigAwsIntegrationModule } from './integration/nestjs-config-integration.module';
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/nestjs-config-aws/src/integration/index.js

@@ -0,0 +1,7 @@
+// Integration module exports
+export * from './interfaces';
+export * from './nestjs-config-integration.module';
+export * from './providers';
+export * from './services';
+export * from './utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvaW50ZWdyYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsNkJBQTZCO0FBQzdCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBJbnRlZ3JhdGlvbiBtb2R1bGUgZXhwb3J0c1xyXG5leHBvcnQgKiBmcm9tICcuL2ludGVyZmFjZXMnO1xyXG5leHBvcnQgKiBmcm9tICcuL25lc3Rqcy1jb25maWctaW50ZWdyYXRpb24ubW9kdWxlJztcclxuZXhwb3J0ICogZnJvbSAnLi9wcm92aWRlcnMnO1xyXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzJztcclxuZXhwb3J0ICogZnJvbSAnLi91dGlscyc7Il19

package/dist/esm/nestjs-config-aws/src/integration/interfaces/configuration-factory.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/nestjs-config-aws/src/integration/interfaces/configuration-source.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlndXJhdGlvbi1zb3VyY2UuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2ludGVncmF0aW9uL2ludGVyZmFjZXMvY29uZmlndXJhdGlvbi1zb3VyY2UuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogVHlwZXMgb2YgY29uZmlndXJhdGlvbiBzb3VyY2VzIHN1cHBvcnRlZCBieSB0aGUgaW50ZWdyYXRpb24uXHJcbiAqL1xyXG5leHBvcnQgdHlwZSBDb25maWd1cmF0aW9uU291cmNlVHlwZSA9ICdlbnZpcm9ubWVudCcgfCAnc2VjcmV0cy1tYW5hZ2VyJyB8ICdzc20nIHwgJ2xvY2FsLWZpbGUnO1xyXG5cclxuLyoqXHJcbiAqIFJlcHJlc2VudHMgYSBjb25maWd1cmF0aW9uIHNvdXJjZSB3aXRoIG1ldGFkYXRhIGFib3V0IGl0cyBvcmlnaW4gYW5kIHN0YXRlLlxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBDb25maWd1cmF0aW9uU291cmNlIHtcclxuICAvKiogSHVtYW4tcmVhZGFibGUgbmFtZSBvZiB0aGUgY29uZmlndXJhdGlvbiBzb3VyY2UgKi9cclxuICBuYW1lOiBzdHJpbmc7XHJcbiAgLyoqIFR5cGUgb2YgdGhlIGNvbmZpZ3VyYXRpb24gc291cmNlICovXHJcbiAgdHlwZTogQ29uZmlndXJhdGlvblNvdXJjZVR5cGU7XHJcbiAgLyoqIFByaW9yaXR5IG9mIHRoaXMgc291cmNlIChoaWdoZXIgbnVtYmVycyBoYXZlIGhpZ2hlciBwcmlvcml0eSkgKi9cclxuICBwcmlvcml0eTogbnVtYmVyO1xyXG4gIC8qKiBUaGUgY29uZmlndXJhdGlvbiBkYXRhIGZyb20gdGhpcyBzb3VyY2UgKi9cclxuICBkYXRhOiBSZWNvcmQ8c3RyaW5nLCBhbnk+O1xyXG4gIC8qKiBPcHRpb25hbCBuYW1lc3BhY2UgZm9yIHRoaXMgY29uZmlndXJhdGlvbiAqL1xyXG4gIG5hbWVzcGFjZT86IHN0cmluZztcclxuICAvKiogVGltZXN0YW1wIHdoZW4gdGhpcyBjb25maWd1cmF0aW9uIHdhcyBsb2FkZWQgKi9cclxuICBsb2FkZWRBdDogRGF0ZTtcclxuICAvKiogQW55IGVycm9ycyBlbmNvdW50ZXJlZCB3aGlsZSBsb2FkaW5nIHRoaXMgc291cmNlICovXHJcbiAgZXJyb3JzPzogc3RyaW5nW107XHJcbn0iXX0=

package/dist/esm/nestjs-config-aws/src/integration/interfaces/index.js

@@ -0,0 +1,10 @@
+// Integration interfaces exports
+export * from './integration-options.interface';
+export * from './configuration-factory.interface';
+export * from './configuration-source.interface';
+export * from './integration-state.interface';
+export * from './typed-configuration.interface';
+export * from './nestjs-config-integration.interface';
+export * from './nestjs-config-compatibility.interface';
+export * from './utility-types.interface';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvaW50ZWdyYXRpb24vaW50ZXJmYWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxpQ0FBaUM7QUFDakMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLDJCQUEyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gSW50ZWdyYXRpb24gaW50ZXJmYWNlcyBleHBvcnRzXHJcbmV4cG9ydCAqIGZyb20gJy4vaW50ZWdyYXRpb24tb3B0aW9ucy5pbnRlcmZhY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbmZpZ3VyYXRpb24tZmFjdG9yeS5pbnRlcmZhY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbmZpZ3VyYXRpb24tc291cmNlLmludGVyZmFjZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vaW50ZWdyYXRpb24tc3RhdGUuaW50ZXJmYWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi90eXBlZC1jb25maWd1cmF0aW9uLmludGVyZmFjZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbmVzdGpzLWNvbmZpZy1pbnRlZ3JhdGlvbi5pbnRlcmZhY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL25lc3Rqcy1jb25maWctY29tcGF0aWJpbGl0eS5pbnRlcmZhY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL3V0aWxpdHktdHlwZXMuaW50ZXJmYWNlJzsiXX0=

package/dist/esm/nestjs-config-aws/src/integration/interfaces/integration-options.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/nestjs-config-aws/src/integration/interfaces/integration-state.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZWdyYXRpb24tc3RhdGUuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2ludGVncmF0aW9uL2ludGVyZmFjZXMvaW50ZWdyYXRpb24tc3RhdGUuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb25maWd1cmF0aW9uU291cmNlIH0gZnJvbSAnLi9jb25maWd1cmF0aW9uLXNvdXJjZS5pbnRlcmZhY2UnO1xyXG5cclxuLyoqXHJcbiAqIFJlcHJlc2VudHMgdGhlIGN1cnJlbnQgc3RhdGUgb2YgdGhlIGludGVncmF0aW9uIG1vZHVsZS5cclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgSW50ZWdyYXRpb25TdGF0ZSB7XHJcbiAgLyoqIFdoZXRoZXIgdGhlIGludGVncmF0aW9uIGhhcyBiZWVuIGluaXRpYWxpemVkICovXHJcbiAgaXNJbml0aWFsaXplZDogYm9vbGVhbjtcclxuICAvKiogV2hldGhlciBBV1Mgc2VydmljZXMgYXJlIGF2YWlsYWJsZSAqL1xyXG4gIGF3c0F2YWlsYWJsZTogYm9vbGVhbjtcclxuICAvKiogTGlzdCBvZiBjb25maWd1cmF0aW9uIHNvdXJjZXMgdGhhdCBoYXZlIGJlZW4gbG9hZGVkICovXHJcbiAgbG9hZGVkU291cmNlczogQ29uZmlndXJhdGlvblNvdXJjZVtdO1xyXG4gIC8qKiBMaXN0IG9mIGZhY3RvcnkgbmFtZXMgdGhhdCBoYXZlIGJlZW4gcmVnaXN0ZXJlZCB3aXRoIEBuZXN0anMvY29uZmlnICovXHJcbiAgcmVnaXN0ZXJlZEZhY3Rvcmllczogc3RyaW5nW107XHJcbiAgLyoqIEFueSBlcnJvcnMgZW5jb3VudGVyZWQgZHVyaW5nIGluaXRpYWxpemF0aW9uIG9yIG9wZXJhdGlvbiAqL1xyXG4gIGVycm9yczogc3RyaW5nW107XHJcbn0iXX0=

package/dist/esm/nestjs-config-aws/src/integration/interfaces/nestjs-config-compatibility.interface.js

@@ -0,0 +1,64 @@
+import { ConfigService } from '@nestjs/config';
+/**
+ * Decorator for injecting enhanced config service.
+ */
+export const InjectEnhancedConfig = () => {
+    return (_target, _propertyKey, _parameterIndex) => {
+        // Implementation would be handled by the actual decorator
+    };
+};
+/**
+ * Configuration property decorator.
+ */
+export function ConfigProperty(options) {
+    return function (target, propertyKey) {
+        // Store metadata for the property
+        Reflect.defineMetadata('config:property', options, target, propertyKey);
+    };
+}
+/**
+ * Configuration class decorator.
+ */
+export function ConfigClass(options) {
+    return function (target) {
+        // Store metadata for the class
+        Reflect.defineMetadata('config:class', options || {}, target);
+        return target;
+    };
+}
+/**
+ * Configuration validation decorator.
+ */
+export function ValidateConfig(options) {
+    return function (target) {
+        // Store validation metadata
+        Reflect.defineMetadata('config:validation', options, target);
+        return target;
+    };
+}
+/**
+ * Configuration transformer decorator.
+ */
+export function TransformConfig(transformer) {
+    return function (target, propertyKey) {
+        // Store transformer metadata
+        Reflect.defineMetadata('config:transformer', transformer, target, propertyKey);
+    };
+}
+/**
+ * Create a type-safe configuration factory.
+ */
+export function createTypeSafeConfigFactory(key, factory) {
+    const configFactory = () => {
+        const configService = new ConfigService();
+        return factory(configService);
+    };
+    configFactory.KEY = key;
+    configFactory.asProvider = () => ({
+        provide: key,
+        useFactory: factory,
+        inject: [ConfigService],
+    });
+    return configFactory;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nestjs-config-compatibility.interface.js","sourceRoot":"","sources":["../../../../../../src/integration/interfaces/nestjs-config-compatibility.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAsH/C;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAuB,EAAE;IAC3D,OAAO,CAAC,OAAY,EAAE,YAAyC,EAAE,eAAuB,EAAE,EAAE;QAC1F,0DAA0D;IAC5D,CAAC,CAAC;AACJ,CAAC,CAAC;AAoBF;;GAEG;AACH,MAAM,UAAU,cAAc,CAAC,OAA8B;IAC3D,OAAO,UAAU,MAAW,EAAE,WAA4B;QACxD,kCAAkC;QAClC,OAAO,CAAC,cAAc,CAAC,iBAAiB,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;IAC1E,CAAC,CAAC;AACJ,CAAC;AAcD;;GAEG;AACH,MAAM,UAAU,WAAW,CAAC,OAA4B;IACtD,OAAO,UAA8B,MAAS;QAC5C,+BAA+B;QAC/B,OAAO,CAAC,cAAc,CAAC,cAAc,EAAE,OAAO,IAAI,EAAE,EAAE,MAAM,CAAC,CAAC;QAC9D,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC;AAcD;;GAEG;AACH,MAAM,UAAU,cAAc,CAAC,OAAgC;IAC7D,OAAO,UAA8B,MAAS;QAC5C,4BAA4B;QAC5B,OAAO,CAAC,cAAc,CAAC,mBAAmB,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAC7D,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC;AAeD;;GAEG;AACH,MAAM,UAAU,eAAe,CAC7B,WAA+C;IAE/C,OAAO,UAAU,MAAW,EAAE,WAA4B;QACxD,6BAA6B;QAC7B,OAAO,CAAC,cAAc,CAAC,oBAAoB,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;IACjF,CAAC,CAAC;AACJ,CAAC;AAeD;;GAEG;AACH,MAAM,UAAU,2BAA2B,CACzC,GAAW,EACX,OAAqC;IAErC,MAAM,aAAa,GAAG,GAAG,EAAE;QACzB,MAAM,aAAa,GAAG,IAAI,aAAa,EAAE,CAAC;QAC1C,OAAO,OAAO,CAAC,aAAa,CAAC,CAAC;IAChC,CAAC,CAAC;IACD,aAAqB,CAAC,GAAG,GAAG,GAAG,CAAC;IAChC,aAAqB,CAAC,UAAU,GAAG,GAAG,EAAE,CAAC,CAAC;QACzC,OAAO,EAAE,GAAG;QACZ,UAAU,EAAE,OAAO;QACnB,MAAM,EAAE,CAAC,aAAa,CAAC;KACxB,CAAC,CAAC;IACH,OAAO,aAAyC,CAAC;AACnD,CAAC","sourcesContent":["import { ConfigService } from '@nestjs/config';\r\nimport { Type } from '@nestjs/common';\r\n\r\n/**\r\n * Enhanced ConfigService that provides AWS integration capabilities.\r\n */\r\nexport interface EnhancedConfigService extends ConfigService {\r\n  /**\r\n   * Get configuration value with AWS source information.\r\n   * @param propertyPath - Configuration property path\r\n   * @param defaultValue - Default value if property is not found\r\n   * @returns Configuration value with source metadata\r\n   */\r\n  getWithSource<T = any>(propertyPath: string, defaultValue?: T): ConfigValueWithSource<T>;\r\n\r\n  /**\r\n   * Get configuration value from AWS sources only.\r\n   * @param propertyPath - Configuration property path\r\n   * @param defaultValue - Default value if property is not found\r\n   * @returns Configuration value from AWS sources\r\n   */\r\n  getFromAws<T = any>(propertyPath: string, defaultValue?: T): T | undefined;\r\n\r\n  /**\r\n   * Get configuration value from local sources only.\r\n   * @param propertyPath - Configuration property path\r\n   * @param defaultValue - Default value if property is not found\r\n   * @returns Configuration value from local sources\r\n   */\r\n  getFromLocal<T = any>(propertyPath: string, defaultValue?: T): T | undefined;\r\n\r\n  /**\r\n   * Check if a configuration value comes from AWS sources.\r\n   * @param propertyPath - Configuration property path\r\n   * @returns True if value comes from AWS, false otherwise\r\n   */\r\n  isFromAws(propertyPath: string): boolean;\r\n\r\n  /**\r\n   * Get all configuration keys from AWS sources.\r\n   * @returns Array of configuration keys from AWS sources\r\n   */\r\n  getAwsKeys(): string[];\r\n\r\n  /**\r\n   * Get all configuration keys from local sources.\r\n   * @returns Array of configuration keys from local sources\r\n   */\r\n  getLocalKeys(): string[];\r\n\r\n  /**\r\n   * Get configuration source information for a property.\r\n   * @param propertyPath - Configuration property path\r\n   * @returns Source information or undefined\r\n   */\r\n  getSourceInfo(propertyPath: string): ConfigSourceInfo | undefined;\r\n\r\n  /**\r\n   * Refresh AWS configuration values.\r\n   * @returns Promise that resolves when refresh is complete\r\n   */\r\n  refreshAwsConfig(): Promise<void>;\r\n\r\n  /**\r\n   * Get configuration health status.\r\n   * @returns Configuration health information\r\n   */\r\n  getHealthStatus(): ConfigHealthStatus;\r\n}\r\n\r\n/**\r\n * Configuration value with source metadata.\r\n */\r\nexport interface ConfigValueWithSource<T = any> {\r\n  /** The configuration value */\r\n  value: T;\r\n  /** Source information */\r\n  source: ConfigSourceInfo;\r\n  /** Whether the value was found */\r\n  found: boolean;\r\n}\r\n\r\n/**\r\n * Configuration source information.\r\n */\r\nexport interface ConfigSourceInfo {\r\n  /** Source type */\r\n  type: 'environment' | 'secrets-manager' | 'ssm' | 'local-file';\r\n  /** Whether this is an AWS source */\r\n  isAws: boolean;\r\n  /** Source priority */\r\n  priority: number;\r\n  /** Namespace if applicable */\r\n  namespace?: string;\r\n  /** When the value was loaded */\r\n  loadedAt: Date;\r\n  /** Original key used to load the value */\r\n  originalKey?: string;\r\n}\r\n\r\n/**\r\n * Configuration health status.\r\n */\r\nexport interface ConfigHealthStatus {\r\n  /** Overall health status */\r\n  healthy: boolean;\r\n  /** AWS services availability */\r\n  awsAvailable: boolean;\r\n  /** Number of loaded configuration sources */\r\n  sourcesLoaded: number;\r\n  /** Number of failed sources */\r\n  sourcesFailed: number;\r\n  /** Last successful AWS load time */\r\n  lastAwsLoad?: Date;\r\n  /** Any health issues */\r\n  issues: string[];\r\n}\r\n\r\n/**\r\n * Decorator for injecting enhanced config service.\r\n */\r\nexport const InjectEnhancedConfig = (): ParameterDecorator => {\r\n  return (_target: any, _propertyKey: string | symbol | undefined, _parameterIndex: number) => {\r\n    // Implementation would be handled by the actual decorator\r\n  };\r\n};\r\n\r\n/**\r\n * Configuration property decorator for type-safe configuration access.\r\n */\r\nexport interface ConfigPropertyOptions {\r\n  /** Configuration key */\r\n  key: string;\r\n  /** Default value */\r\n  defaultValue?: any;\r\n  /** Whether to require the property */\r\n  required?: boolean;\r\n  /** Validation function */\r\n  validate?: (value: any) => boolean;\r\n  /** Transformation function */\r\n  transform?: (value: any) => any;\r\n  /** Whether to prefer AWS sources */\r\n  preferAws?: boolean;\r\n}\r\n\r\n/**\r\n * Configuration property decorator.\r\n */\r\nexport function ConfigProperty(options: ConfigPropertyOptions): PropertyDecorator {\r\n  return function (target: any, propertyKey: string | symbol) {\r\n    // Store metadata for the property\r\n    Reflect.defineMetadata('config:property', options, target, propertyKey);\r\n  };\r\n}\r\n\r\n/**\r\n * Configuration class decorator for automatic configuration injection.\r\n */\r\nexport interface ConfigClassOptions {\r\n  /** Configuration namespace */\r\n  namespace?: string;\r\n  /** Whether to validate all properties */\r\n  validate?: boolean;\r\n  /** Whether to prefer AWS sources */\r\n  preferAws?: boolean;\r\n}\r\n\r\n/**\r\n * Configuration class decorator.\r\n */\r\nexport function ConfigClass(options?: ConfigClassOptions): ClassDecorator {\r\n  return function <T extends Function>(target: T) {\r\n    // Store metadata for the class\r\n    Reflect.defineMetadata('config:class', options || {}, target);\r\n    return target;\r\n  };\r\n}\r\n\r\n/**\r\n * Configuration validation decorator.\r\n */\r\nexport interface ConfigValidationOptions {\r\n  /** Validation schema */\r\n  schema?: any;\r\n  /** Custom validation function */\r\n  validator?: (config: any) => boolean | Promise<boolean>;\r\n  /** Whether to throw on validation failure */\r\n  throwOnError?: boolean;\r\n}\r\n\r\n/**\r\n * Configuration validation decorator.\r\n */\r\nexport function ValidateConfig(options: ConfigValidationOptions): ClassDecorator {\r\n  return function <T extends Function>(target: T) {\r\n    // Store validation metadata\r\n    Reflect.defineMetadata('config:validation', options, target);\r\n    return target;\r\n  };\r\n}\r\n\r\n/**\r\n * Configuration transformer interface.\r\n */\r\nexport interface ConfigTransformer<TInput = any, TOutput = any> {\r\n  /**\r\n   * Transform configuration value.\r\n   * @param value - Input value\r\n   * @param key - Configuration key\r\n   * @returns Transformed value\r\n   */\r\n  transform(value: TInput, key: string): TOutput;\r\n}\r\n\r\n/**\r\n * Configuration transformer decorator.\r\n */\r\nexport function TransformConfig<TInput, TOutput>(\r\n  transformer: ConfigTransformer<TInput, TOutput>\r\n): PropertyDecorator {\r\n  return function (target: any, propertyKey: string | symbol) {\r\n    // Store transformer metadata\r\n    Reflect.defineMetadata('config:transformer', transformer, target, propertyKey);\r\n  };\r\n}\r\n\r\n/**\r\n * Configuration factory with enhanced type safety.\r\n */\r\nexport interface TypeSafeConfigFactory<T = any> {\r\n  (): T;\r\n  KEY: string;\r\n  asProvider(): {\r\n    provide: string;\r\n    useFactory: () => T;\r\n    inject: [ConfigService];\r\n  };\r\n}\r\n\r\n/**\r\n * Create a type-safe configuration factory.\r\n */\r\nexport function createTypeSafeConfigFactory<T>(\r\n  key: string,\r\n  factory: (config: ConfigService) => T\r\n): TypeSafeConfigFactory<T> {\r\n  const configFactory = () => {\r\n    const configService = new ConfigService();\r\n    return factory(configService);\r\n  };\r\n  (configFactory as any).KEY = key;\r\n  (configFactory as any).asProvider = () => ({\r\n    provide: key,\r\n    useFactory: factory,\r\n    inject: [ConfigService],\r\n  });\r\n  return configFactory as TypeSafeConfigFactory<T>;\r\n}\r\n\r\n/**\r\n * Configuration module builder for enhanced setup.\r\n */\r\nexport interface ConfigModuleBuilder {\r\n  /**\r\n   * Add AWS integration.\r\n   */\r\n  withAwsIntegration(options: any): ConfigModuleBuilder;\r\n\r\n  /**\r\n   * Add configuration factories.\r\n   */\r\n  withFactories(factories: TypeSafeConfigFactory[]): ConfigModuleBuilder;\r\n\r\n  /**\r\n   * Add validation.\r\n   */\r\n  withValidation(schema: any): ConfigModuleBuilder;\r\n\r\n  /**\r\n   * Set as global module.\r\n   */\r\n  asGlobal(): ConfigModuleBuilder;\r\n\r\n  /**\r\n   * Enable caching.\r\n   */\r\n  withCaching(): ConfigModuleBuilder;\r\n\r\n  /**\r\n   * Build the module.\r\n   */\r\n  build(): Type<any>;\r\n}\r\n\r\n/**\r\n * Configuration testing utilities.\r\n */\r\nexport interface ConfigTestingUtils {\r\n  /**\r\n   * Create a mock config service.\r\n   */\r\n  createMockConfigService(config: Record<string, any>): EnhancedConfigService;\r\n\r\n  /**\r\n   * Create test configuration module.\r\n   */\r\n  createTestConfigModule(config: Record<string, any>): Type<any>;\r\n\r\n  /**\r\n   * Mock AWS configuration sources.\r\n   */\r\n  mockAwsSources(config: Record<string, any>): void;\r\n\r\n  /**\r\n   * Reset all mocks.\r\n   */\r\n  resetMocks(): void;\r\n}\r\n\r\n/**\r\n * Configuration monitoring interface.\r\n */\r\nexport interface ConfigMonitor {\r\n  /**\r\n   * Start monitoring configuration changes.\r\n   */\r\n  startMonitoring(): void;\r\n\r\n  /**\r\n   * Stop monitoring configuration changes.\r\n   */\r\n  stopMonitoring(): void;\r\n\r\n  /**\r\n   * Get configuration metrics.\r\n   */\r\n  getMetrics(): ConfigMetrics;\r\n\r\n  /**\r\n   * Subscribe to configuration events.\r\n   */\r\n  subscribe(callback: (event: ConfigEvent) => void): () => void;\r\n}\r\n\r\n/**\r\n * Configuration metrics.\r\n */\r\nexport interface ConfigMetrics {\r\n  /** Total configuration loads */\r\n  totalLoads: number;\r\n  /** Successful AWS loads */\r\n  successfulAwsLoads: number;\r\n  /** Failed AWS loads */\r\n  failedAwsLoads: number;\r\n  /** Average load time */\r\n  averageLoadTime: number;\r\n  /** Last load time */\r\n  lastLoadTime?: Date;\r\n  /** Configuration cache hit rate */\r\n  cacheHitRate: number;\r\n}\r\n\r\n/**\r\n * Configuration event.\r\n */\r\nexport interface ConfigEvent {\r\n  /** Event type */\r\n  type: 'loaded' | 'updated' | 'error' | 'validated';\r\n  /** Event timestamp */\r\n  timestamp: Date;\r\n  /** Event data */\r\n  data: any;\r\n  /** Source of the event */\r\n  source: string;\r\n}\r\n\r\n/**\r\n * Configuration audit log entry.\r\n */\r\nexport interface ConfigAuditEntry {\r\n  /** Audit entry ID */\r\n  id: string;\r\n  /** Timestamp */\r\n  timestamp: Date;\r\n  /** Action performed */\r\n  action: 'load' | 'update' | 'delete' | 'validate';\r\n  /** Configuration key affected */\r\n  key: string;\r\n  /** Old value (for updates) */\r\n  oldValue?: any;\r\n  /** New value */\r\n  newValue?: any;\r\n  /** Source of the change */\r\n  source: string;\r\n  /** User or system that made the change */\r\n  actor: string;\r\n}\r\n\r\n/**\r\n * Configuration audit logger.\r\n */\r\nexport interface ConfigAuditLogger {\r\n  /**\r\n   * Log a configuration change.\r\n   */\r\n  log(entry: Omit<ConfigAuditEntry, 'id' | 'timestamp'>): void;\r\n\r\n  /**\r\n   * Get audit log entries.\r\n   */\r\n  getEntries(filter?: Partial<ConfigAuditEntry>): ConfigAuditEntry[];\r\n\r\n  /**\r\n   * Clear audit log.\r\n   */\r\n  clear(): void;\r\n}"]}

package/dist/esm/nestjs-config-aws/src/integration/interfaces/nestjs-config-integration.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nestjs-config-integration.interface.js","sourceRoot":"","sources":["../../../../../../src/integration/interfaces/nestjs-config-integration.interface.ts"],"names":[],"mappings":"","sourcesContent":["import { ConfigFactory, ConfigModuleOptions } from '@nestjs/config';\r\nimport { DynamicModule, ModuleMetadata, Type } from '@nestjs/common';\r\nimport { IntegrationOptions } from './integration-options.interface';\r\nimport { ConfigurationSource } from './configuration-source.interface';\r\nimport { TypedConfiguration, ConfigurationSchema } from './typed-configuration.interface';\r\n\r\n/**\r\n * Enhanced module options that extend @nestjs/config options with AWS integration.\r\n */\r\nexport interface EnhancedConfigModuleOptions extends ConfigModuleOptions {\r\n  /** AWS integration options */\r\n  awsIntegration?: IntegrationOptions;\r\n  /** Whether to enable AWS configuration loading */\r\n  enableAwsIntegration?: boolean;\r\n  /** Custom configuration schemas for type safety */\r\n  schemas?: ConfigurationSchema[];\r\n}\r\n\r\n/**\r\n * Factory function type for creating enhanced configuration modules.\r\n */\r\nexport type EnhancedConfigModuleFactory = (\r\n  options?: EnhancedConfigModuleOptions\r\n) => DynamicModule;\r\n\r\n/**\r\n * Async factory function type for creating enhanced configuration modules.\r\n */\r\nexport type EnhancedAsyncConfigModuleFactory = (\r\n  options: EnhancedAsyncConfigModuleOptions\r\n) => DynamicModule;\r\n\r\n/**\r\n * Async options for enhanced configuration module.\r\n */\r\nexport interface EnhancedAsyncConfigModuleOptions extends ModuleMetadata {\r\n  /** Factory function to create enhanced configuration options */\r\n  useFactory?: (\r\n    ...args: any[]\r\n  ) => Promise<EnhancedConfigModuleOptions> | EnhancedConfigModuleOptions;\r\n  \r\n  /** Class to use as factory */\r\n  useClass?: Type<EnhancedConfigModuleOptionsFactory>;\r\n  \r\n  /** Existing instance to use as factory */\r\n  useExisting?: Type<EnhancedConfigModuleOptionsFactory>;\r\n  \r\n  /** Dependencies to inject into the factory function */\r\n  inject?: any[];\r\n}\r\n\r\n/**\r\n * Factory interface for creating enhanced configuration module options.\r\n */\r\nexport interface EnhancedConfigModuleOptionsFactory {\r\n  /**\r\n   * Create enhanced configuration module options.\r\n   * @returns Enhanced configuration module options\r\n   */\r\n  createConfigOptions(): Promise<EnhancedConfigModuleOptions> | EnhancedConfigModuleOptions;\r\n}\r\n\r\n/**\r\n * Integration service interface for managing AWS and @nestjs/config integration.\r\n */\r\nexport interface NestJSConfigIntegrationService {\r\n  /**\r\n   * Initialize the integration with @nestjs/config.\r\n   * @param options - Integration options\r\n   */\r\n  initialize(options: IntegrationOptions): Promise<void>;\r\n\r\n  /**\r\n   * Register configuration factories with @nestjs/config.\r\n   * @param factories - Configuration factories to register\r\n   */\r\n  registerFactories(factories: ConfigFactory[]): Promise<void>;\r\n\r\n  /**\r\n   * Get configuration from AWS sources and format for @nestjs/config.\r\n   * @param namespaces - Optional namespaces to load\r\n   * @returns Configuration data organized for @nestjs/config\r\n   */\r\n  getConfigurationForNestJS(namespaces?: string[]): Promise<Record<string, any>>;\r\n\r\n  /**\r\n   * Create configuration factories from AWS sources.\r\n   * @param sources - Configuration sources from AWS\r\n   * @param namespaces - Optional namespaces to organize configuration\r\n   * @returns Array of configuration factories\r\n   */\r\n  createFactoriesFromAwsSources(\r\n    sources: ConfigurationSource[],\r\n    namespaces?: string[]\r\n  ): ConfigFactory[];\r\n\r\n  /**\r\n   * Merge AWS configuration with existing @nestjs/config configuration.\r\n   * @param awsConfig - Configuration from AWS sources\r\n   * @param existingConfig - Existing @nestjs/config configuration\r\n   * @returns Merged configuration\r\n   */\r\n  mergeWithExistingConfig(\r\n    awsConfig: Record<string, any>,\r\n    existingConfig: Record<string, any>\r\n  ): Record<string, any>;\r\n\r\n  /**\r\n   * Validate configuration using @nestjs/config validation patterns.\r\n   * @param config - Configuration to validate\r\n   * @param validationSchema - Optional validation schema\r\n   * @returns Validation result\r\n   */\r\n  validateConfiguration(\r\n    config: Record<string, any>,\r\n    validationSchema?: any\r\n  ): Promise<boolean>;\r\n\r\n  /**\r\n   * Get typed configuration with full type safety.\r\n   * @param key - Configuration key or namespace\r\n   * @returns Typed configuration\r\n   */\r\n  getTypedConfiguration<T = any>(key: string): TypedConfiguration<T> | undefined;\r\n\r\n  /**\r\n   * Check if the integration is properly initialized.\r\n   * @returns True if initialized, false otherwise\r\n   */\r\n  isInitialized(): boolean;\r\n\r\n  /**\r\n   * Get integration status and health information.\r\n   * @returns Integration status information\r\n   */\r\n  getStatus(): IntegrationStatus;\r\n}\r\n\r\n/**\r\n * Integration status information.\r\n */\r\nexport interface IntegrationStatus {\r\n  /** Whether the integration is initialized */\r\n  initialized: boolean;\r\n  /** Whether AWS services are available */\r\n  awsAvailable: boolean;\r\n  /** Number of configuration sources loaded */\r\n  sourcesLoaded: number;\r\n  /** Number of factories registered */\r\n  factoriesRegistered: number;\r\n  /** Any errors encountered */\r\n  errors: string[];\r\n  /** Last update timestamp */\r\n  lastUpdated: Date;\r\n}\r\n\r\n/**\r\n * Configuration loader interface for AWS integration with @nestjs/config.\r\n */\r\nexport interface AwsConfigurationLoader {\r\n  /**\r\n   * Load configuration from AWS sources for @nestjs/config integration.\r\n   * @param options - Integration options\r\n   * @returns Promise resolving to configuration data\r\n   */\r\n  loadForNestJSConfig(options: IntegrationOptions): Promise<Record<string, any>>;\r\n\r\n  /**\r\n   * Load namespaced configuration from AWS sources.\r\n   * @param namespaces - Namespaces to load\r\n   * @param options - Integration options\r\n   * @returns Promise resolving to namespaced configuration data\r\n   */\r\n  loadNamespacedForNestJSConfig(\r\n    namespaces: string[],\r\n    options: IntegrationOptions\r\n  ): Promise<Record<string, Record<string, any>>>;\r\n\r\n  /**\r\n   * Check if AWS services are available for configuration loading.\r\n   * @returns Promise resolving to availability status\r\n   */\r\n  checkAwsAvailability(): Promise<boolean>;\r\n\r\n  /**\r\n   * Get configuration sources that are available.\r\n   * @param options - Integration options\r\n   * @returns Promise resolving to available sources\r\n   */\r\n  getAvailableSources(options: IntegrationOptions): Promise<string[]>;\r\n}\r\n\r\n/**\r\n * Configuration merger interface for handling precedence rules.\r\n */\r\nexport interface ConfigurationMerger {\r\n  /**\r\n   * Merge configurations with precedence rules.\r\n   * @param sources - Configuration sources to merge\r\n   * @param precedenceRule - Precedence rule to apply\r\n   * @returns Merged configuration\r\n   */\r\n  mergeWithPrecedence(\r\n    sources: ConfigurationSource[],\r\n    precedenceRule: 'aws-first' | 'local-first' | 'merge'\r\n  ): Record<string, any>;\r\n\r\n  /**\r\n   * Merge two configuration objects.\r\n   * @param primary - Primary configuration (higher precedence)\r\n   * @param secondary - Secondary configuration (lower precedence)\r\n   * @returns Merged configuration\r\n   */\r\n  merge(\r\n    primary: Record<string, any>,\r\n    secondary: Record<string, any>\r\n  ): Record<string, any>;\r\n\r\n  /**\r\n   * Deep merge configuration objects with conflict resolution.\r\n   * @param configs - Array of configuration objects to merge\r\n   * @param conflictResolution - How to resolve conflicts\r\n   * @returns Merged configuration\r\n   */\r\n  deepMerge(\r\n    configs: Record<string, any>[],\r\n    conflictResolution?: 'first-wins' | 'last-wins' | 'merge-arrays'\r\n  ): Record<string, any>;\r\n}\r\n\r\n/**\r\n * Configuration validator interface for AWS-sourced values.\r\n */\r\nexport interface AwsConfigurationValidator {\r\n  /**\r\n   * Validate configuration using Joi schema.\r\n   * @param config - Configuration to validate\r\n   * @param schema - Joi validation schema\r\n   * @returns Validation result\r\n   */\r\n  validateWithJoi(config: Record<string, any>, schema: any): Promise<boolean>;\r\n\r\n  /**\r\n   * Validate configuration using class-validator.\r\n   * @param config - Configuration to validate\r\n   * @param validationClass - Class with validation decorators\r\n   * @returns Validation result\r\n   */\r\n  validateWithClassValidator(config: Record<string, any>, validationClass: any): Promise<boolean>;\r\n\r\n  /**\r\n   * Validate configuration using custom validation function.\r\n   * @param config - Configuration to validate\r\n   * @param validationFn - Custom validation function\r\n   * @returns Validation result\r\n   */\r\n  validateWithCustomFunction(\r\n    config: Record<string, any>,\r\n    validationFn: (config: any) => boolean | Promise<boolean>\r\n  ): Promise<boolean>;\r\n\r\n  /**\r\n   * Get validation errors for configuration.\r\n   * @param config - Configuration to validate\r\n   * @param schema - Validation schema\r\n   * @returns Array of validation errors\r\n   */\r\n  getValidationErrors(config: Record<string, any>, schema: any): string[];\r\n}\r\n\r\n/**\r\n * Utility type for extracting configuration type from @nestjs/config factory.\r\n */\r\nexport type ExtractConfigType<T> = T extends () => infer U ? U : never;\r\n\r\n/**\r\n * Utility type for creating strongly typed configuration service.\r\n */\r\nexport type TypedConfigService<T extends Record<string, ConfigFactory>> = {\r\n  get<K extends keyof T>(key: K): ExtractConfigType<T[K]> | undefined;\r\n  getOrThrow<K extends keyof T>(key: K): ExtractConfigType<T[K]>;\r\n};\r\n\r\n/**\r\n * Configuration namespace registry for managing namespaced configurations.\r\n */\r\nexport interface ConfigurationNamespaceRegistry {\r\n  /**\r\n   * Register a namespace with its configuration factory.\r\n   * @param namespace - Namespace name\r\n   * @param factory - Configuration factory for the namespace\r\n   */\r\n  register(namespace: string, factory: ConfigFactory): void;\r\n\r\n  /**\r\n   * Get a configuration factory by namespace.\r\n   * @param namespace - Namespace name\r\n   * @returns Configuration factory or undefined\r\n   */\r\n  get(namespace: string): ConfigFactory | undefined;\r\n\r\n  /**\r\n   * Check if a namespace is registered.\r\n   * @param namespace - Namespace name\r\n   * @returns True if registered, false otherwise\r\n   */\r\n  has(namespace: string): boolean;\r\n\r\n  /**\r\n   * Get all registered namespaces.\r\n   * @returns Array of namespace names\r\n   */\r\n  getNamespaces(): string[];\r\n\r\n  /**\r\n   * Unregister a namespace.\r\n   * @param namespace - Namespace name\r\n   */\r\n  unregister(namespace: string): void;\r\n\r\n  /**\r\n   * Clear all registered namespaces.\r\n   */\r\n  clear(): void;\r\n}"]}

package/dist/esm/nestjs-config-aws/src/integration/interfaces/typed-configuration.interface.js

@@ -0,0 +1,3 @@
+// Type definitions for typed configuration access
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typed-configuration.interface.js","sourceRoot":"","sources":["../../../../../../src/integration/interfaces/typed-configuration.interface.ts"],"names":[],"mappings":"AAAA,kDAAkD","sourcesContent":["// Type definitions for typed configuration access\r\n\r\n/**\r\n * Generic type for typed configuration access.\r\n * Provides type safety for configuration values loaded from AWS sources.\r\n */\r\nexport interface TypedConfiguration<T = any> {\r\n  /** The configuration data with proper typing */\r\n  data: T;\r\n  /** Namespace for this configuration */\r\n  namespace?: string;\r\n  /** Whether this configuration was loaded from AWS sources */\r\n  fromAws: boolean;\r\n  /** Timestamp when this configuration was loaded */\r\n  loadedAt: Date;\r\n}\r\n\r\n/**\r\n * Generic configuration factory with type safety.\r\n */\r\nexport interface TypedConfigurationFactory<T = any> {\r\n  /** Type-safe configuration data */\r\n  (): T;\r\n}\r\n\r\n/**\r\n * Configuration accessor with type safety for AWS-sourced values.\r\n */\r\nexport interface TypedConfigurationAccessor {\r\n  /**\r\n   * Get typed configuration value with type safety.\r\n   * @param key - Configuration key (supports dot notation)\r\n   * @returns Typed configuration value\r\n   */\r\n  get<T = any>(key: string): T | undefined;\r\n\r\n  /**\r\n   * Get typed configuration value or throw if not found.\r\n   * @param key - Configuration key (supports dot notation)\r\n   * @returns Typed configuration value\r\n   * @throws Error if key is not found\r\n   */\r\n  getOrThrow<T = any>(key: string): T;\r\n\r\n  /**\r\n   * Get namespaced typed configuration.\r\n   * @param namespace - Configuration namespace\r\n   * @returns Typed configuration for the namespace\r\n   */\r\n  getNamespaced<T = any>(namespace: string): TypedConfiguration<T> | undefined;\r\n\r\n  /**\r\n   * Get namespaced typed configuration or throw if not found.\r\n   * @param namespace - Configuration namespace\r\n   * @returns Typed configuration for the namespace\r\n   * @throws Error if namespace is not found\r\n   */\r\n  getNamespacedOrThrow<T = any>(namespace: string): TypedConfiguration<T>;\r\n\r\n  /**\r\n   * Check if a configuration key exists.\r\n   * @param key - Configuration key (supports dot notation)\r\n   * @returns True if key exists, false otherwise\r\n   */\r\n  has(key: string): boolean;\r\n\r\n  /**\r\n   * Check if a namespace exists.\r\n   * @param namespace - Configuration namespace\r\n   * @returns True if namespace exists, false otherwise\r\n   */\r\n  hasNamespace(namespace: string): boolean;\r\n\r\n  /**\r\n   * Get all configuration keys.\r\n   * @returns Array of all configuration keys\r\n   */\r\n  getKeys(): string[];\r\n\r\n  /**\r\n   * Get all namespaces.\r\n   * @returns Array of all namespaces\r\n   */\r\n  getNamespaces(): string[];\r\n}\r\n\r\n/**\r\n * Type-safe configuration schema definition.\r\n */\r\nexport interface ConfigurationSchema<T = any> {\r\n  /** Schema name/identifier */\r\n  name: string;\r\n  /** Optional namespace for this schema */\r\n  namespace?: string;\r\n  /** Type definition for the configuration */\r\n  type: new () => T;\r\n  /** Optional validation function */\r\n  validate?: (config: any) => config is T;\r\n  /** Optional default values */\r\n  defaults?: Partial<T>;\r\n}\r\n\r\n/**\r\n * Configuration registry for managing typed configurations.\r\n */\r\nexport interface TypedConfigurationRegistry {\r\n  /**\r\n   * Register a typed configuration schema.\r\n   * @param schema - Configuration schema to register\r\n   */\r\n  register<T>(schema: ConfigurationSchema<T>): void;\r\n\r\n  /**\r\n   * Get a typed configuration by name.\r\n   * @param name - Schema name\r\n   * @returns Typed configuration or undefined\r\n   */\r\n  get<T = any>(name: string): TypedConfiguration<T> | undefined;\r\n\r\n  /**\r\n   * Get a typed configuration by name or throw if not found.\r\n   * @param name - Schema name\r\n   * @returns Typed configuration\r\n   * @throws Error if schema is not found\r\n   */\r\n  getOrThrow<T = any>(name: string): TypedConfiguration<T>;\r\n\r\n  /**\r\n   * Check if a schema is registered.\r\n   * @param name - Schema name\r\n   * @returns True if schema is registered, false otherwise\r\n   */\r\n  has(name: string): boolean;\r\n\r\n  /**\r\n   * Get all registered schema names.\r\n   * @returns Array of schema names\r\n   */\r\n  getSchemaNames(): string[];\r\n\r\n  /**\r\n   * Unregister a schema.\r\n   * @param name - Schema name to unregister\r\n   */\r\n  unregister(name: string): void;\r\n\r\n  /**\r\n   * Clear all registered schemas.\r\n   */\r\n  clear(): void;\r\n}\r\n\r\n/**\r\n * Options for typed configuration access.\r\n */\r\nexport interface TypedConfigurationOptions {\r\n  /** Whether to enable strict type checking */\r\n  strictTypes?: boolean;\r\n  /** Whether to cache typed configurations */\r\n  cache?: boolean;\r\n  /** Default namespace for unnamespaced configurations */\r\n  defaultNamespace?: string;\r\n  /** Whether to throw on type validation failures */\r\n  throwOnValidationError?: boolean;\r\n}\r\n\r\n/**\r\n * Utility type for extracting configuration type from a factory.\r\n */\r\nexport type ConfigurationType<T> = T extends TypedConfigurationFactory<infer U> ? U : never;\r\n\r\n/**\r\n * Utility type for creating strongly typed configuration objects.\r\n */\r\nexport type StronglyTypedConfig<T extends Record<string, any>> = {\r\n  readonly [K in keyof T]: T[K];\r\n};\r\n\r\n/**\r\n * Configuration value with metadata about its source and type.\r\n */\r\nexport interface ConfigurationValue<T = any> {\r\n  /** The actual configuration value */\r\n  value: T;\r\n  /** Source of this configuration value */\r\n  source: 'environment' | 'secrets-manager' | 'ssm' | 'local-file';\r\n  /** Whether this value came from AWS */\r\n  fromAws: boolean;\r\n  /** Namespace this value belongs to */\r\n  namespace?: string;\r\n  /** Original key used to access this value */\r\n  key: string;\r\n  /** Type of the value */\r\n  type: string;\r\n  /** Whether this value was validated */\r\n  validated: boolean;\r\n  /** Timestamp when this value was loaded */\r\n  loadedAt: Date;\r\n}\r\n\r\n/**\r\n * Configuration path resolver for nested configuration access.\r\n */\r\nexport interface ConfigurationPathResolver {\r\n  /**\r\n   * Resolve a configuration path to its value.\r\n   * @param path - Configuration path (supports dot notation)\r\n   * @param config - Configuration object to resolve against\r\n   * @returns Resolved value or undefined\r\n   */\r\n  resolve<T = any>(path: string, config: Record<string, any>): T | undefined;\r\n\r\n  /**\r\n   * Set a value at a configuration path.\r\n   * @param path - Configuration path (supports dot notation)\r\n   * @param value - Value to set\r\n   * @param config - Configuration object to modify\r\n   */\r\n  set<T = any>(path: string, value: T, config: Record<string, any>): void;\r\n\r\n  /**\r\n   * Check if a configuration path exists.\r\n   * @param path - Configuration path (supports dot notation)\r\n   * @param config - Configuration object to check\r\n   * @returns True if path exists, false otherwise\r\n   */\r\n  exists(path: string, config: Record<string, any>): boolean;\r\n\r\n  /**\r\n   * Get all paths in a configuration object.\r\n   * @param config - Configuration object to analyze\r\n   * @returns Array of all configuration paths\r\n   */\r\n  getAllPaths(config: Record<string, any>): string[];\r\n}"]}