@dyanet/nestjs-config-aws 1.2.1 → 2.0.0

package/dist/cjs/interfaces/module-options.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/services/config.service.js

@@ -0,0 +1,142 @@
+"use strict";
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var ConfigServiceImpl_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigServiceImpl = void 0;
+const common_1 = require("@nestjs/common");
+const config_aws_1 = require("@dyanet/config-aws");
+const config_service_interface_1 = require("../interfaces/config-service.interface");
+/**
+ * NestJS Injectable wrapper around ConfigManager from @dyanet/config-aws.
+ * Provides type-safe configuration access with NestJS dependency injection support.
+ *
+ * This is a thin adapter layer that delegates all configuration loading and
+ * management to the framework-agnostic ConfigManager from config-aws.
+ *
+ * @example
+ * ```typescript
+ * import { ConfigServiceImpl } from '@dyanet/nestjs-config-aws';
+ * import { z } from 'zod';
+ *
+ * const schema = z.object({
+ *   DATABASE_URL: z.string(),
+ *   PORT: z.coerce.number().default(3000),
+ * });
+ *
+ * const configService = new ConfigServiceImpl({
+ *   loaders: [new EnvironmentLoader()],
+ *   schema,
+ * });
+ *
+ * await configService.initialize();
+ * const dbUrl = configService.get('DATABASE_URL');
+ * ```
+ */
+let ConfigServiceImpl = ConfigServiceImpl_1 = class ConfigServiceImpl extends config_service_interface_1.ConfigService {
+    logger = new common_1.Logger(ConfigServiceImpl_1.name);
+    configManager;
+    enableNestLogging;
+    constructor(options = {}) {
+        super();
+        this.enableNestLogging = options.enableNestLogging ?? true;
+        // Create ConfigManager from config-aws with provided options
+        this.configManager = new config_aws_1.ConfigManager({
+            loaders: options.loaders,
+            schema: options.schema,
+            precedence: options.precedence,
+            validateOnLoad: options.validateOnLoad,
+            enableLogging: options.enableLogging,
+            logger: options.logger,
+            verbose: options.verbose,
+        });
+    }
+    /**
+     * Initialize the configuration service by loading configuration from all sources.
+     * This method should be called during application startup.
+     *
+     * @throws ConfigurationError if loading or validation fails
+     */
+    async initialize() {
+        if (this.configManager.isLoaded()) {
+            return;
+        }
+        try {
+            if (this.enableNestLogging) {
+                this.logger.log('Initializing configuration service...');
+            }
+            await this.configManager.load();
+            if (this.enableNestLogging) {
+                this.logger.log('Configuration service initialized successfully');
+            }
+        }
+        catch (error) {
+            const errorMessage = `Failed to initialize configuration service: ${error instanceof Error ? error.message : String(error)}`;
+            this.logger.error(errorMessage);
+            throw error;
+        }
+    }
+    /**
+     * Get a configuration value by key with type safety.
+     *
+     * @param key - The configuration key to retrieve
+     * @returns The configuration value with proper typing
+     * @throws ConfigurationError if configuration is not initialized
+     */
+    get(key) {
+        if (!this.configManager.isLoaded()) {
+            throw new config_aws_1.ConfigurationError('Configuration service not initialized. Call initialize() first.');
+        }
+        return this.configManager.get(key);
+    }
+    /**
+     * Check if the configuration service has been initialized.
+     *
+     * @returns True if the service is ready to serve configuration values
+     */
+    isInitialized() {
+        return this.configManager.isLoaded();
+    }
+    /**
+     * Get all configuration values.
+     *
+     * @returns The complete configuration object
+     * @throws ConfigurationError if configuration is not initialized
+     */
+    getAll() {
+        if (!this.configManager.isLoaded()) {
+            throw new config_aws_1.ConfigurationError('Configuration service not initialized. Call initialize() first.');
+        }
+        return this.configManager.getAll();
+    }
+    /**
+     * Get the current application environment.
+     *
+     * @returns The APP_ENV value or 'development' as default
+     */
+    getAppEnv() {
+        return this.configManager.getAppEnv();
+    }
+    /**
+     * Get the underlying ConfigManager instance.
+     * Useful for advanced use cases that need direct access to ConfigManager features.
+     *
+     * @returns The ConfigManager instance from @dyanet/config-aws
+     */
+    getConfigManager() {
+        return this.configManager;
+    }
+};
+exports.ConfigServiceImpl = ConfigServiceImpl;
+exports.ConfigServiceImpl = ConfigServiceImpl = ConfigServiceImpl_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object])
+], ConfigServiceImpl);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.service.js","sourceRoot":"","sources":["../../../src/services/config.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,2CAAoD;AACpD,mDAAuE;AAGvE,qFAAuE;AAcvE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEI,IAAM,iBAAiB,yBAAvB,MAAM,iBAA+C,SAAQ,wCAAgB;IACjE,MAAM,GAAG,IAAI,eAAM,CAAC,mBAAiB,CAAC,IAAI,CAAC,CAAC;IAC5C,aAAa,CAAmB;IAChC,iBAAiB,CAAU;IAE5C,YAAY,UAAmC,EAAE;QAC/C,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,IAAI,IAAI,CAAC;QAE3D,6DAA6D;QAC7D,IAAI,CAAC,aAAa,GAAG,IAAI,0BAAa,CAAI;YACxC,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,cAAc,EAAE,OAAO,CAAC,cAAc;YACtC,aAAa,EAAE,OAAO,CAAC,aAAa;YACpC,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,OAAO,EAAE,OAAO,CAAC,OAAO;SACzB,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,UAAU;QACd,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,EAAE,CAAC;YAClC,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC3B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,uCAAuC,CAAC,CAAC;YAC3D,CAAC;YAED,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;YAEhC,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC3B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,gDAAgD,CAAC,CAAC;YACpE,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,YAAY,GAAG,+CAA+C,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YAC7H,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAChC,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,GAAG,CAAoB,GAAM;QAC3B,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,EAAE,CAAC;YACnC,MAAM,IAAI,+BAAkB,CAC1B,iEAAiE,CAClE,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACrC,CAAC;IAED;;;;OAIG;IACH,aAAa;QACX,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;IACvC,CAAC;IAED;;;;;OAKG;IACH,MAAM;QACJ,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,EAAE,CAAC;YACnC,MAAM,IAAI,+BAAkB,CAC1B,iEAAiE,CAClE,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC;IACrC,CAAC;IAED;;;;OAIG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACH,gBAAgB;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;CACF,CAAA;AA5GY,8CAAiB;4BAAjB,iBAAiB;IAD7B,IAAA,mBAAU,GAAE;;GACA,iBAAiB,CA4G7B","sourcesContent":["import { Injectable, Logger } from '@nestjs/common';\r\nimport { ConfigManager, ConfigurationError } from '@dyanet/config-aws';\r\nimport type { ConfigManagerOptions } from '@dyanet/config-aws';\r\n\r\nimport { ConfigService } from '../interfaces/config-service.interface';\r\n\r\n/**\r\n * Configuration options for NestJS ConfigService wrapper.\r\n * Extends ConfigManagerOptions from @dyanet/config-aws.\r\n */\r\nexport interface ConfigServiceOptions<T = Record<string, unknown>> extends ConfigManagerOptions<T> {\r\n  /**\r\n   * Whether to enable NestJS logging\r\n   * @default true\r\n   */\r\n  enableNestLogging?: boolean;\r\n}\r\n\r\n/**\r\n * NestJS Injectable wrapper around ConfigManager from @dyanet/config-aws.\r\n * Provides type-safe configuration access with NestJS dependency injection support.\r\n * \r\n * This is a thin adapter layer that delegates all configuration loading and\r\n * management to the framework-agnostic ConfigManager from config-aws.\r\n * \r\n * @example\r\n * ```typescript\r\n * import { ConfigServiceImpl } from '@dyanet/nestjs-config-aws';\r\n * import { z } from 'zod';\r\n * \r\n * const schema = z.object({\r\n *   DATABASE_URL: z.string(),\r\n *   PORT: z.coerce.number().default(3000),\r\n * });\r\n * \r\n * const configService = new ConfigServiceImpl({\r\n *   loaders: [new EnvironmentLoader()],\r\n *   schema,\r\n * });\r\n * \r\n * await configService.initialize();\r\n * const dbUrl = configService.get('DATABASE_URL');\r\n * ```\r\n */\r\n@Injectable()\r\nexport class ConfigServiceImpl<T = Record<string, unknown>> extends ConfigService<T> {\r\n  private readonly logger = new Logger(ConfigServiceImpl.name);\r\n  private readonly configManager: ConfigManager<T>;\r\n  private readonly enableNestLogging: boolean;\r\n\r\n  constructor(options: ConfigServiceOptions<T> = {}) {\r\n    super();\r\n    \r\n    this.enableNestLogging = options.enableNestLogging ?? true;\r\n    \r\n    // Create ConfigManager from config-aws with provided options\r\n    this.configManager = new ConfigManager<T>({\r\n      loaders: options.loaders,\r\n      schema: options.schema,\r\n      precedence: options.precedence,\r\n      validateOnLoad: options.validateOnLoad,\r\n      enableLogging: options.enableLogging,\r\n      logger: options.logger,\r\n      verbose: options.verbose,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Initialize the configuration service by loading configuration from all sources.\r\n   * This method should be called during application startup.\r\n   * \r\n   * @throws ConfigurationError if loading or validation fails\r\n   */\r\n  async initialize(): Promise<void> {\r\n    if (this.configManager.isLoaded()) {\r\n      return;\r\n    }\r\n\r\n    try {\r\n      if (this.enableNestLogging) {\r\n        this.logger.log('Initializing configuration service...');\r\n      }\r\n\r\n      await this.configManager.load();\r\n\r\n      if (this.enableNestLogging) {\r\n        this.logger.log('Configuration service initialized successfully');\r\n      }\r\n    } catch (error) {\r\n      const errorMessage = `Failed to initialize configuration service: ${error instanceof Error ? error.message : String(error)}`;\r\n      this.logger.error(errorMessage);\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get a configuration value by key with type safety.\r\n   * \r\n   * @param key - The configuration key to retrieve\r\n   * @returns The configuration value with proper typing\r\n   * @throws ConfigurationError if configuration is not initialized\r\n   */\r\n  get<K extends keyof T>(key: K): T[K] {\r\n    if (!this.configManager.isLoaded()) {\r\n      throw new ConfigurationError(\r\n        'Configuration service not initialized. Call initialize() first.'\r\n      );\r\n    }\r\n    return this.configManager.get(key);\r\n  }\r\n\r\n  /**\r\n   * Check if the configuration service has been initialized.\r\n   * \r\n   * @returns True if the service is ready to serve configuration values\r\n   */\r\n  isInitialized(): boolean {\r\n    return this.configManager.isLoaded();\r\n  }\r\n\r\n  /**\r\n   * Get all configuration values.\r\n   * \r\n   * @returns The complete configuration object\r\n   * @throws ConfigurationError if configuration is not initialized\r\n   */\r\n  getAll(): T {\r\n    if (!this.configManager.isLoaded()) {\r\n      throw new ConfigurationError(\r\n        'Configuration service not initialized. Call initialize() first.'\r\n      );\r\n    }\r\n    return this.configManager.getAll();\r\n  }\r\n\r\n  /**\r\n   * Get the current application environment.\r\n   * \r\n   * @returns The APP_ENV value or 'development' as default\r\n   */\r\n  getAppEnv(): string {\r\n    return this.configManager.getAppEnv();\r\n  }\r\n\r\n  /**\r\n   * Get the underlying ConfigManager instance.\r\n   * Useful for advanced use cases that need direct access to ConfigManager features.\r\n   * \r\n   * @returns The ConfigManager instance from @dyanet/config-aws\r\n   */\r\n  getConfigManager(): ConfigManager<T> {\r\n    return this.configManager;\r\n  }\r\n}\r\n"]}

package/dist/esm/aws-config-loader.js

@@ -0,0 +1,54 @@
+import { ConfigManager } from '@dyanet/config-aws';
+import { buildAwsLoaders } from './build-loaders.js';
+/**
+ * Create a configuration factory that loads from AWS sources (Secrets Manager,
+ * SSM Parameter Store) and environment variables, for use with the standard
+ * `@nestjs/config` `ConfigModule`.
+ *
+ * The returned function matches `@nestjs/config`'s `ConfigFactory` shape, so drop
+ * it straight into the `load` array — no extra module to import, and
+ * `@nestjs/config` stays an optional peer dependency of this package.
+ *
+ * @example
+ * ```typescript
+ * import { ConfigModule } from '@nestjs/config';
+ * import { awsConfigLoader } from '@dyanet/nestjs-config-aws';
+ *
+ * @Module({
+ *   imports: [
+ *     ConfigModule.forRoot({
+ *       isGlobal: true,
+ *       // Simple `aws` shape — same as the Next.js adapter's getConfig:
+ *       load: [awsConfigLoader({ aws: { secretName: '/my-app/config' } })],
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * @example Namespaced (compose with `@nestjs/config`'s `registerAs`):
+ * ```typescript
+ * import { ConfigModule, registerAs } from '@nestjs/config';
+ *
+ * ConfigModule.forRoot({
+ *   load: [registerAs('database', awsConfigLoader({ ssmConfig: { paths: { production: '/db' } } }))],
+ * });
+ * ```
+ *
+ * @param options Loader options.
+ * @returns A factory `() => Promise<T>` suitable for `ConfigModule`'s `load` array.
+ */
+export function awsConfigLoader(options = {}) {
+    return async () => {
+        const manager = new ConfigManager({
+            loaders: buildAwsLoaders(options),
+            schema: options.schema,
+            precedence: options.precedence ?? 'aws-first',
+            validateOnLoad: options.validate ?? Boolean(options.schema),
+            enableLogging: options.enableLogging ?? false,
+        });
+        await manager.load();
+        return manager.getAll();
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/build-loaders.js

@@ -0,0 +1,55 @@
+import { EnvironmentLoader, SecretsManagerLoader, SSMParameterStoreLoader, } from '@dyanet/config-aws';
+/**
+ * Map an optional `{ development, test, production }` path config to the
+ * environment mapping expected by the AWS loaders, falling back to sensible
+ * defaults. Returns `undefined` when no paths are supplied so the loader uses
+ * its own defaults.
+ */
+function toEnvironmentMapping(paths) {
+    if (!paths) {
+        return undefined;
+    }
+    return {
+        development: paths.development || 'dev',
+        test: paths.test || 'test',
+        production: paths.production || 'production',
+    };
+}
+/**
+ * Build the configuration loader chain from AWS source options.
+ *
+ * Order (lowest precedence first): environment variables, then Secrets Manager,
+ * then SSM Parameter Store. The AWS loaders skip themselves automatically when
+ * unavailable (e.g. in a local environment or without credentials).
+ */
+export function buildAwsLoaders(options) {
+    const loaders = [];
+    // Always add environment loader first (lowest precedence)
+    loaders.push(new EnvironmentLoader({ prefix: options.envPrefix }));
+    // Simple, Next.js-style `aws` option: add exactly the named sources.
+    if (options.aws) {
+        const { secretName, ssmPrefix, region } = options.aws;
+        if (secretName) {
+            loaders.push(new SecretsManagerLoader({ secretName, region }));
+        }
+        if (ssmPrefix) {
+            loaders.push(new SSMParameterStoreLoader({ parameterPath: ssmPrefix, region }));
+        }
+        return loaders;
+    }
+    if (options.secretsManagerConfig?.enabled !== false) {
+        loaders.push(new SecretsManagerLoader({
+            region: options.secretsManagerConfig?.region,
+            environmentMapping: toEnvironmentMapping(options.secretsManagerConfig?.paths),
+        }));
+    }
+    if (options.ssmConfig?.enabled !== false) {
+        loaders.push(new SSMParameterStoreLoader({
+            region: options.ssmConfig?.region,
+            withDecryption: options.ssmConfig?.decrypt,
+            environmentMapping: toEnvironmentMapping(options.ssmConfig?.paths),
+        }));
+    }
+    return loaders;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/config.module.js

@@ -0,0 +1,135 @@
+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 { ConfigService } from './interfaces/config-service.interface.js';
+import { ConfigServiceImpl } from './services/config.service.js';
+import { buildAwsLoaders } from './build-loaders.js';
+/**
+ * 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 = buildAwsLoaders(options);
+                // Create ConfigService options. No schema => values are returned as-is
+                // (ConfigManager only validates when a schema is provided).
+                const serviceOptions = {
+                    schema: options.schema,
+                    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 = buildAwsLoaders(options);
+                // Create ConfigService options. No schema => values are returned as-is.
+                const serviceOptions = {
+                    schema: options.schema,
+                    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],
+        };
+    }
+};
+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":";;;;;;;AAAA,OAAO,EAAiB,MAAM,EAAE,MAAM,EAAY,MAAM,gBAAgB,CAAC;AAEzE,OAAO,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAEtE,OAAO,EAAE,iBAAiB,EAAwB,MAAM,2BAA2B,CAAC;AACpF,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAElD;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,yBAAyB,CAAC;AAEjE;;;;GAIG;AAGI,IAAM,YAAY,oBAAlB,MAAM,YAAY;IACvB;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CACZ,UAAyC,EAAE;QAE3C,MAAM,qBAAqB,GAAG,IAAI,CAAC,2BAA2B,CAAC,OAAO,CAAC,CAAC;QAExE,OAAO;YACL,MAAM,EAAE,cAAY;YACpB,SAAS,EAAE;gBACT;oBACE,OAAO,EAAE,uBAAuB;oBAChC,QAAQ,EAAE,OAAO;iBAClB;gBACD,qBAAqB;aACtB;YACD,OAAO,EAAE,CAAC,aAAa,CAAC;YACxB,MAAM,EAAE,IAAI;SACb,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,YAAY,CACjB,OAA2C;QAE3C,MAAM,cAAc,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAE1D,OAAO;YACL,MAAM,EAAE,cAAY;YACpB,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,EAAE;YAC9B,SAAS,EAAE;gBACT,GAAG,cAAc;gBACjB,IAAI,CAAC,gCAAgC,EAAE;aACxC;YACD,OAAO,EAAE,CAAC,aAAa,CAAC;YACxB,MAAM,EAAE,IAAI;SACb,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,2BAA2B,CACxC,OAAsC;QAEtC,OAAO;YACL,OAAO,EAAE,aAAa;YACtB,UAAU,EAAE,KAAK,IAA+B,EAAE;gBAChD,wCAAwC;gBACxC,MAAM,OAAO,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC;gBAEzC,uEAAuE;gBACvE,4DAA4D;gBAC5D,MAAM,cAAc,GAA4B;oBAC9C,MAAM,EAAE,OAAO,CAAC,MAAM;oBACtB,OAAO;oBACP,cAAc,EAAE,CAAC,OAAO,CAAC,sBAAsB;oBAC/C,aAAa,EAAE,IAAI;iBACpB,CAAC;gBAEF,oCAAoC;gBACpC,MAAM,aAAa,GAAG,IAAI,iBAAiB,CAAI,cAAc,CAAC,CAAC;gBAE/D,uDAAuD;gBACvD,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;oBACtB,MAAM,aAAa,CAAC,UAAU,EAAE,CAAC;gBACnC,CAAC;gBAED,OAAO,aAAiC,CAAC;YAC3C,CAAC;SACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,oBAAoB,CACjC,OAA2C;QAE3C,OAAO;YACL;gBACE,OAAO,EAAE,uBAAuB;gBAChC,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,EAAE;aAC7B;SACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,gCAAgC;QAC7C,OAAO;YACL,OAAO,EAAE,aAAa;YACtB,UAAU,EAAE,KAAK,EAAE,OAAmC,EAA0B,EAAE;gBAChF,wCAAwC;gBACxC,MAAM,OAAO,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC;gBAEzC,wEAAwE;gBACxE,MAAM,cAAc,GAAyB;oBAC3C,MAAM,EAAE,OAAO,CAAC,MAAM;oBACtB,OAAO;oBACP,cAAc,EAAE,CAAC,OAAO,CAAC,sBAAsB;oBAC/C,aAAa,EAAE,IAAI;iBACpB,CAAC;gBAEF,oCAAoC;gBACpC,MAAM,aAAa,GAAG,IAAI,iBAAiB,CAAC,cAAc,CAAC,CAAC;gBAE5D,uDAAuD;gBACvD,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;oBACtB,MAAM,aAAa,CAAC,UAAU,EAAE,CAAC;gBACnC,CAAC;gBAED,OAAO,aAA8B,CAAC;YACxC,CAAC;YACD,MAAM,EAAE,CAAC,uBAAuB,CAAC;SAClC,CAAC;IACJ,CAAC;CACF,CAAA;AAlIY,YAAY;IAFxB,MAAM,EAAE;IACR,MAAM,CAAC,EAAE,CAAC;GACE,YAAY,CAkIxB","sourcesContent":["import { DynamicModule, Global, Module, Provider } from '@nestjs/common';\r\n\r\nimport { ConfigService } from './interfaces/config-service.interface';\r\nimport { NestConfigAwsModuleOptions, NestConfigAwsModuleAsyncOptions } from './interfaces/module-options.interface';\r\nimport { ConfigServiceImpl, ConfigServiceOptions } from './services/config.service';\r\nimport { buildAwsLoaders } from './build-loaders';\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 = Record<string, unknown>>(\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 = Record<string, unknown>>(\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 = buildAwsLoaders(options);\r\n\r\n        // Create ConfigService options. No schema => values are returned as-is\r\n        // (ConfigManager only validates when a schema is provided).\r\n        const serviceOptions: ConfigServiceOptions<T> = {\r\n          schema: options.schema,\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 = buildAwsLoaders(options);\r\n\r\n        // Create ConfigService options. No schema => values are returned as-is.\r\n        const serviceOptions: ConfigServiceOptions = {\r\n          schema: options.schema,\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"]}

package/dist/esm/index.js

@@ -0,0 +1,18 @@
+// 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 dependency-injection module + service
+export * from './config.module.js';
+export * from './interfaces/index.js';
+export * from './services/config.service.js';
+// @nestjs/config integration: a single factory helper for the `load` array
+export { awsConfigLoader } from './aws-config-loader.js';
+export { buildAwsLoaders } from './build-loaders.js';
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/interfaces/config-service.interface.js

@@ -0,0 +1,7 @@
+/**
+ * Abstract ConfigService interface for dependency injection.
+ * Provides type-safe access to configuration values with generic type support.
+ */
+export class ConfigService {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLXNlcnZpY2UuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2ludGVyZmFjZXMvY29uZmlnLXNlcnZpY2UuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUNILE1BQU0sT0FBZ0IsYUFBYTtDQW1CbEMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQWJzdHJhY3QgQ29uZmlnU2VydmljZSBpbnRlcmZhY2UgZm9yIGRlcGVuZGVuY3kgaW5qZWN0aW9uLlxyXG4gKiBQcm92aWRlcyB0eXBlLXNhZmUgYWNjZXNzIHRvIGNvbmZpZ3VyYXRpb24gdmFsdWVzIHdpdGggZ2VuZXJpYyB0eXBlIHN1cHBvcnQuXHJcbiAqL1xyXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQ29uZmlnU2VydmljZTxUID0gYW55PiB7XHJcbiAgLyoqXHJcbiAgICogR2V0IGEgY29uZmlndXJhdGlvbiB2YWx1ZSBieSBrZXkgd2l0aCB0eXBlIHNhZmV0eS5cclxuICAgKiBAcGFyYW0ga2V5IC0gVGhlIGNvbmZpZ3VyYXRpb24ga2V5IHRvIHJldHJpZXZlXHJcbiAgICogQHJldHVybnMgVGhlIGNvbmZpZ3VyYXRpb24gdmFsdWUgd2l0aCBwcm9wZXIgdHlwaW5nXHJcbiAgICovXHJcbiAgYWJzdHJhY3QgZ2V0PEsgZXh0ZW5kcyBrZXlvZiBUPihrZXk6IEspOiBUW0tdO1xyXG5cclxuICAvKipcclxuICAgKiBDaGVjayBpZiB0aGUgY29uZmlndXJhdGlvbiBzZXJ2aWNlIGhhcyBiZWVuIGluaXRpYWxpemVkLlxyXG4gICAqIEByZXR1cm5zIFRydWUgaWYgdGhlIHNlcnZpY2UgaXMgcmVhZHkgdG8gc2VydmUgY29uZmlndXJhdGlvbiB2YWx1ZXNcclxuICAgKi9cclxuICBhYnN0cmFjdCBpc0luaXRpYWxpemVkKCk6IGJvb2xlYW47XHJcblxyXG4gIC8qKlxyXG4gICAqIEdldCBhbGwgY29uZmlndXJhdGlvbiB2YWx1ZXMuXHJcbiAgICogQHJldHVybnMgVGhlIGNvbXBsZXRlIGNvbmZpZ3VyYXRpb24gb2JqZWN0XHJcbiAgICovXHJcbiAgYWJzdHJhY3QgZ2V0QWxsKCk6IFQ7XHJcbn1cclxuIl19

package/dist/esm/interfaces/default-schema.interface.js

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+/**
+ * Default configuration schema using Zod.
+ * Provides a flexible base schema that can be extended by applications.
+ */
+export const defaultConfigSchema = z.object({
+    /** Node.js environment */
+    NODE_ENV: z.enum(['production', 'development', 'test']).optional(),
+    /** Application environment (mirrors NODE_ENV with 'local' default) */
+    APP_ENV: z.enum(['production', 'test', 'development', 'local']).default('local'),
+    /** AWS region for services */
+    AWS_REGION: z.string().optional(),
+    /** AWS profile for local development */
+    AWS_PROFILE: z.string().optional(),
+    /** Application port */
+    PORT: z.coerce.number().positive().optional(),
+    /** Application host */
+    HOST: z.string().optional(),
+    /** Log level */
+    LOG_LEVEL: z.enum(['error', 'warn', 'info', 'debug', 'verbose']).optional(),
+    /** Database URL */
+    DATABASE_URL: z.string().url().optional(),
+    /** Redis URL */
+    REDIS_URL: z.string().url().optional(),
+});
+/**
+ * Environment-specific validation schemas.
+ */
+export const environmentSchemas = {
+    local: defaultConfigSchema.extend({
+        // Local environment may have fewer required fields
+        AWS_REGION: z.string().optional(),
+    }),
+    development: defaultConfigSchema.extend({
+        // Development environment requirements
+        AWS_REGION: z.string().min(1, 'AWS_REGION is required in development'),
+    }),
+    test: defaultConfigSchema.extend({
+        // Test environment requirements
+        AWS_REGION: z.string().min(1, 'AWS_REGION is required in test'),
+    }),
+    production: defaultConfigSchema.extend({
+        // Production environment requirements
+        AWS_REGION: z.string().min(1, 'AWS_REGION is required in production'),
+        LOG_LEVEL: z.enum(['error', 'warn', 'info']).default('info'),
+    }),
+};
+/**
+ * Helper function to get the appropriate schema for the current environment.
+ */
+export function getSchemaForEnvironment(appEnv) {
+    const env = appEnv;
+    return environmentSchemas[env] || defaultConfigSchema;
+}
+/**
+ * Validation helper for APP_ENV values.
+ */
+export const appEnvSchema = z.enum(['production', 'test', 'development', 'local']);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1zY2hlbWEuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2ludGVyZmFjZXMvZGVmYXVsdC1zY2hlbWEuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEI7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsQ0FBQyxDQUFDLE1BQU0sQ0FBQztJQUMxQywwQkFBMEI7SUFDMUIsUUFBUSxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxZQUFZLEVBQUUsYUFBYSxFQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUMsUUFBUSxFQUFFO0lBRWxFLHNFQUFzRTtJQUN0RSxPQUFPLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLFlBQVksRUFBRSxNQUFNLEVBQUUsYUFBYSxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQztJQUVoRiw4QkFBOEI7SUFDOUIsVUFBVSxFQUFFLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxRQUFRLEVBQUU7SUFFakMsd0NBQXdDO0lBQ3hDLFdBQVcsRUFBRSxDQUFDLENBQUMsTUFBTSxFQUFFLENBQUMsUUFBUSxFQUFFO0lBRWxDLHVCQUF1QjtJQUN2QixJQUFJLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxRQUFRLEVBQUU7SUFFN0MsdUJBQXVCO0lBQ3ZCLElBQUksRUFBRSxDQUFDLENBQUMsTUFBTSxFQUFFLENBQUMsUUFBUSxFQUFFO0lBRTNCLGdCQUFnQjtJQUNoQixTQUFTLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxTQUFTLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRTtJQUUzRSxtQkFBbUI7SUFDbkIsWUFBWSxFQUFFLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxRQUFRLEVBQUU7SUFFekMsZ0JBQWdCO0lBQ2hCLFNBQVMsRUFBRSxDQUFDLENBQUMsTUFBTSxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsUUFBUSxFQUFFO0NBQ3ZDLENBQUMsQ0FBQztBQU9IOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUc7SUFDaEMsS0FBSyxFQUFFLG1CQUFtQixDQUFDLE1BQU0sQ0FBQztRQUNoQyxtREFBbUQ7UUFDbkQsVUFBVSxFQUFFLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxRQUFRLEVBQUU7S0FDbEMsQ0FBQztJQUVGLFdBQVcsRUFBRSxtQkFBbUIsQ0FBQyxNQUFNLENBQUM7UUFDdEMsdUNBQXVDO1FBQ3ZDLFVBQVUsRUFBRSxDQUFDLENBQUMsTUFBTSxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSx1Q0FBdUMsQ0FBQztLQUN2RSxDQUFDO0lBRUYsSUFBSSxFQUFFLG1CQUFtQixDQUFDLE1BQU0sQ0FBQztRQUMvQixnQ0FBZ0M7UUFDaEMsVUFBVSxFQUFFLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLGdDQUFnQyxDQUFDO0tBQ2hFLENBQUM7SUFFRixVQUFVLEVBQUUsbUJBQW1CLENBQUMsTUFBTSxDQUFDO1FBQ3JDLHNDQUFzQztRQUN0QyxVQUFVLEVBQUUsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsc0NBQXNDLENBQUM7UUFDckUsU0FBUyxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQztLQUM3RCxDQUFDO0NBQ0gsQ0FBQztBQUVGOztHQUVHO0FBQ0gsTUFBTSxVQUFVLHVCQUF1QixDQUFDLE1BQWM7SUFDcEQsTUFBTSxHQUFHLEdBQUcsTUFBeUMsQ0FBQztJQUN0RCxPQUFPLGtCQUFrQixDQUFDLEdBQUcsQ0FBQyxJQUFJLG1CQUFtQixDQUFDO0FBQ3hELENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsWUFBWSxFQUFFLE1BQU0sRUFBRSxhQUFhLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHogfSBmcm9tICd6b2QnO1xyXG5cclxuLyoqXHJcbiAqIERlZmF1bHQgY29uZmlndXJhdGlvbiBzY2hlbWEgdXNpbmcgWm9kLlxyXG4gKiBQcm92aWRlcyBhIGZsZXhpYmxlIGJhc2Ugc2NoZW1hIHRoYXQgY2FuIGJlIGV4dGVuZGVkIGJ5IGFwcGxpY2F0aW9ucy5cclxuICovXHJcbmV4cG9ydCBjb25zdCBkZWZhdWx0Q29uZmlnU2NoZW1hID0gei5vYmplY3Qoe1xyXG4gIC8qKiBOb2RlLmpzIGVudmlyb25tZW50ICovXHJcbiAgTk9ERV9FTlY6IHouZW51bShbJ3Byb2R1Y3Rpb24nLCAnZGV2ZWxvcG1lbnQnLCAndGVzdCddKS5vcHRpb25hbCgpLFxyXG4gIFxyXG4gIC8qKiBBcHBsaWNhdGlvbiBlbnZpcm9ubWVudCAobWlycm9ycyBOT0RFX0VOViB3aXRoICdsb2NhbCcgZGVmYXVsdCkgKi9cclxuICBBUFBfRU5WOiB6LmVudW0oWydwcm9kdWN0aW9uJywgJ3Rlc3QnLCAnZGV2ZWxvcG1lbnQnLCAnbG9jYWwnXSkuZGVmYXVsdCgnbG9jYWwnKSxcclxuICBcclxuICAvKiogQVdTIHJlZ2lvbiBmb3Igc2VydmljZXMgKi9cclxuICBBV1NfUkVHSU9OOiB6LnN0cmluZygpLm9wdGlvbmFsKCksXHJcbiAgXHJcbiAgLyoqIEFXUyBwcm9maWxlIGZvciBsb2NhbCBkZXZlbG9wbWVudCAqL1xyXG4gIEFXU19QUk9GSUxFOiB6LnN0cmluZygpLm9wdGlvbmFsKCksXHJcbiAgXHJcbiAgLyoqIEFwcGxpY2F0aW9uIHBvcnQgKi9cclxuICBQT1JUOiB6LmNvZXJjZS5udW1iZXIoKS5wb3NpdGl2ZSgpLm9wdGlvbmFsKCksXHJcbiAgXHJcbiAgLyoqIEFwcGxpY2F0aW9uIGhvc3QgKi9cclxuICBIT1NUOiB6LnN0cmluZygpLm9wdGlvbmFsKCksXHJcbiAgXHJcbiAgLyoqIExvZyBsZXZlbCAqL1xyXG4gIExPR19MRVZFTDogei5lbnVtKFsnZXJyb3InLCAnd2FybicsICdpbmZvJywgJ2RlYnVnJywgJ3ZlcmJvc2UnXSkub3B0aW9uYWwoKSxcclxuICBcclxuICAvKiogRGF0YWJhc2UgVVJMICovXHJcbiAgREFUQUJBU0VfVVJMOiB6LnN0cmluZygpLnVybCgpLm9wdGlvbmFsKCksXHJcbiAgXHJcbiAgLyoqIFJlZGlzIFVSTCAqL1xyXG4gIFJFRElTX1VSTDogei5zdHJpbmcoKS51cmwoKS5vcHRpb25hbCgpLFxyXG59KTtcclxuXHJcbi8qKlxyXG4gKiBUeXBlIGluZmVyZW5jZSBmb3IgdGhlIGRlZmF1bHQgY29uZmlndXJhdGlvbiBzY2hlbWEuXHJcbiAqL1xyXG5leHBvcnQgdHlwZSBEZWZhdWx0Q29uZmlnU2NoZW1hID0gei5pbmZlcjx0eXBlb2YgZGVmYXVsdENvbmZpZ1NjaGVtYT47XHJcblxyXG4vKipcclxuICogRW52aXJvbm1lbnQtc3BlY2lmaWMgdmFsaWRhdGlvbiBzY2hlbWFzLlxyXG4gKi9cclxuZXhwb3J0IGNvbnN0IGVudmlyb25tZW50U2NoZW1hcyA9IHtcclxuICBsb2NhbDogZGVmYXVsdENvbmZpZ1NjaGVtYS5leHRlbmQoe1xyXG4gICAgLy8gTG9jYWwgZW52aXJvbm1lbnQgbWF5IGhhdmUgZmV3ZXIgcmVxdWlyZWQgZmllbGRzXHJcbiAgICBBV1NfUkVHSU9OOiB6LnN0cmluZygpLm9wdGlvbmFsKCksXHJcbiAgfSksXHJcbiAgXHJcbiAgZGV2ZWxvcG1lbnQ6IGRlZmF1bHRDb25maWdTY2hlbWEuZXh0ZW5kKHtcclxuICAgIC8vIERldmVsb3BtZW50IGVudmlyb25tZW50IHJlcXVpcmVtZW50c1xyXG4gICAgQVdTX1JFR0lPTjogei5zdHJpbmcoKS5taW4oMSwgJ0FXU19SRUdJT04gaXMgcmVxdWlyZWQgaW4gZGV2ZWxvcG1lbnQnKSxcclxuICB9KSxcclxuICBcclxuICB0ZXN0OiBkZWZhdWx0Q29uZmlnU2NoZW1hLmV4dGVuZCh7XHJcbiAgICAvLyBUZXN0IGVudmlyb25tZW50IHJlcXVpcmVtZW50c1xyXG4gICAgQVdTX1JFR0lPTjogei5zdHJpbmcoKS5taW4oMSwgJ0FXU19SRUdJT04gaXMgcmVxdWlyZWQgaW4gdGVzdCcpLFxyXG4gIH0pLFxyXG4gIFxyXG4gIHByb2R1Y3Rpb246IGRlZmF1bHRDb25maWdTY2hlbWEuZXh0ZW5kKHtcclxuICAgIC8vIFByb2R1Y3Rpb24gZW52aXJvbm1lbnQgcmVxdWlyZW1lbnRzXHJcbiAgICBBV1NfUkVHSU9OOiB6LnN0cmluZygpLm1pbigxLCAnQVdTX1JFR0lPTiBpcyByZXF1aXJlZCBpbiBwcm9kdWN0aW9uJyksXHJcbiAgICBMT0dfTEVWRUw6IHouZW51bShbJ2Vycm9yJywgJ3dhcm4nLCAnaW5mbyddKS5kZWZhdWx0KCdpbmZvJyksXHJcbiAgfSksXHJcbn07XHJcblxyXG4vKipcclxuICogSGVscGVyIGZ1bmN0aW9uIHRvIGdldCB0aGUgYXBwcm9wcmlhdGUgc2NoZW1hIGZvciB0aGUgY3VycmVudCBlbnZpcm9ubWVudC5cclxuICovXHJcbmV4cG9ydCBmdW5jdGlvbiBnZXRTY2hlbWFGb3JFbnZpcm9ubWVudChhcHBFbnY6IHN0cmluZyk6IHouWm9kU2NoZW1hIHtcclxuICBjb25zdCBlbnYgPSBhcHBFbnYgYXMga2V5b2YgdHlwZW9mIGVudmlyb25tZW50U2NoZW1hcztcclxuICByZXR1cm4gZW52aXJvbm1lbnRTY2hlbWFzW2Vudl0gfHwgZGVmYXVsdENvbmZpZ1NjaGVtYTtcclxufVxyXG5cclxuLyoqXHJcbiAqIFZhbGlkYXRpb24gaGVscGVyIGZvciBBUFBfRU5WIHZhbHVlcy5cclxuICovXHJcbmV4cG9ydCBjb25zdCBhcHBFbnZTY2hlbWEgPSB6LmVudW0oWydwcm9kdWN0aW9uJywgJ3Rlc3QnLCAnZGV2ZWxvcG1lbnQnLCAnbG9jYWwnXSk7XHJcblxyXG4vKipcclxuICogVHlwZSBmb3IgdmFsaWQgQVBQX0VOViB2YWx1ZXMuXHJcbiAqL1xyXG5leHBvcnQgdHlwZSBBcHBFbnYgPSB6LmluZmVyPHR5cGVvZiBhcHBFbnZTY2hlbWE+O1xyXG4iXX0=

package/dist/esm/interfaces/index.js

@@ -0,0 +1,8 @@
+// Core interfaces
+export * from './config-service.interface.js';
+export * from './module-options.interface.js';
+// Error classes - re-export from core for backward compatibility
+export { ConfigurationError, ValidationError, AWSServiceError, ConfigurationLoadError, MissingConfigurationError, } from '@dyanet/config-aws';
+// Default schema and types
+export * from './default-schema.interface.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaW50ZXJmYWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxrQkFBa0I7QUFDbEIsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDRCQUE0QixDQUFDO0FBRTNDLGlFQUFpRTtBQUNqRSxPQUFPLEVBQ0wsa0JBQWtCLEVBQ2xCLGVBQWUsRUFDZixlQUFlLEVBQ2Ysc0JBQXNCLEVBQ3RCLHlCQUF5QixHQUMxQixNQUFNLG9CQUFvQixDQUFDO0FBRTVCLDJCQUEyQjtBQUMzQixjQUFjLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29yZSBpbnRlcmZhY2VzXHJcbmV4cG9ydCAqIGZyb20gJy4vY29uZmlnLXNlcnZpY2UuaW50ZXJmYWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9tb2R1bGUtb3B0aW9ucy5pbnRlcmZhY2UnO1xyXG5cclxuLy8gRXJyb3IgY2xhc3NlcyAtIHJlLWV4cG9ydCBmcm9tIGNvcmUgZm9yIGJhY2t3YXJkIGNvbXBhdGliaWxpdHlcclxuZXhwb3J0IHtcclxuICBDb25maWd1cmF0aW9uRXJyb3IsXHJcbiAgVmFsaWRhdGlvbkVycm9yLFxyXG4gIEFXU1NlcnZpY2VFcnJvcixcclxuICBDb25maWd1cmF0aW9uTG9hZEVycm9yLFxyXG4gIE1pc3NpbmdDb25maWd1cmF0aW9uRXJyb3IsXHJcbn0gZnJvbSAnQGR5YW5ldC9jb25maWctYXdzJztcclxuXHJcbi8vIERlZmF1bHQgc2NoZW1hIGFuZCB0eXBlc1xyXG5leHBvcnQgKiBmcm9tICcuL2RlZmF1bHQtc2NoZW1hLmludGVyZmFjZSc7XHJcbiJdfQ==

package/dist/esm/interfaces/module-options.interface.js

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

package/dist/esm/package.json

@@ -1 +1,3 @@
-{"type":"module"} 
+{
+  "type": "module"
+}