@zintrust/core 0.1.20 → 0.1.21

package/src/config/cache.js

@@ -3,6 +3,7 @@
  * Caching drivers and settings
  * Sealed namespace for immutability
  */
+import { StartupConfigFile, StartupConfigFileRegistry } from '../runtime/StartupConfigFileRegistry.js';
 import { Env } from './env.js';
 import { ErrorFactory } from '../exceptions/ZintrustError.js';
 const getCacheDriver = (config, name) => {
@@ -22,22 +23,16 @@ const getCacheDriver = (config, name) => {
     }
     throw ErrorFactory.createConfigError(`Cache default store not configured: ${storeName || '<empty>'}`);
 };
-const cacheConfigObj = {
-    /**
-     * Default cache driver
-     */
-    default: (() => {
+const createCacheConfig = () => {
+    const baseDefault = (() => {
         const envConnection = Env.get('CACHE_CONNECTION', '').trim();
         const envDriver = typeof Env.CACHE_DRIVER === 'string'
             ? String(Env.CACHE_DRIVER)
             : Env.get('CACHE_DRIVER', 'memory');
         const selected = envConnection.length > 0 ? envConnection : String(envDriver ?? 'memory');
         return selected.trim().toLowerCase();
-    })(),
-    /**
-     * Cache drivers
-     */
-    drivers: {
+    })();
+    const baseDrivers = {
         memory: {
             driver: 'memory',
             ttl: Env.getInt('CACHE_MEMORY_TTL', 3600),
@@ -62,20 +57,69 @@ const cacheConfigObj = {
             driver: 'kv-remote',
             ttl: Env.getInt('CACHE_KV_TTL', 3600),
         },
+    };
+    const overrides = StartupConfigFileRegistry.get(StartupConfigFile.Cache) ?? {};
+    const mergedDrivers = {
+        ...baseDrivers,
+        ...(overrides.drivers ?? {}),
+    };
+    const mergedDefault = typeof overrides.default === 'string' && overrides.default.trim() !== ''
+        ? overrides.default.trim().toLowerCase()
+        : baseDefault;
+    const mergedKeyPrefix = typeof overrides.keyPrefix === 'string' && overrides.keyPrefix.length > 0
+        ? overrides.keyPrefix
+        : Env.get('CACHE_KEY_PREFIX', 'zintrust:');
+    const mergedTtl = typeof overrides.ttl === 'number' && Number.isFinite(overrides.ttl) ? overrides.ttl : 3600;
+    const cacheConfigObj = {
+        /**
+         * Default cache driver
+         */
+        default: mergedDefault,
+        /**
+         * Cache drivers
+         */
+        drivers: mergedDrivers,
+        /**
+         * Get cache driver config
+         */
+        getDriver(name) {
+            return getCacheDriver(this, name);
+        },
+        /**
+         * Key prefix for all cache keys
+         */
+        keyPrefix: mergedKeyPrefix,
+        /**
+         * Default cache TTL (seconds)
+         */
+        ttl: mergedTtl,
+    };
+    return Object.freeze(cacheConfigObj);
+};
+let cached = null;
+const proxyTarget = {};
+const ensureCacheConfig = () => {
+    if (cached)
+        return cached;
+    cached = createCacheConfig();
+    try {
+        Object.defineProperties(proxyTarget, Object.getOwnPropertyDescriptors(cached));
+    }
+    catch {
+        // best-effort
+    }
+    return cached;
+};
+export const cacheConfig = new Proxy(proxyTarget, {
+    get(_target, prop) {
+        return ensureCacheConfig()[prop];
     },
-    /**
-     * Get cache driver config
-     */
-    getDriver(name) {
-        return getCacheDriver(this, name);
+    ownKeys() {
+        ensureCacheConfig();
+        return Reflect.ownKeys(proxyTarget);
     },
-    /**
-     * Key prefix for all cache keys
-     */
-    keyPrefix: Env.get('CACHE_KEY_PREFIX', 'zintrust:'),
-    /**
-     * Default cache TTL (seconds)
-     */
-    ttl: Env.getInt('CACHE_DEFAULT_TTL', 3600),
-};
-export const cacheConfig = Object.freeze(cacheConfigObj);
+    getOwnPropertyDescriptor(_target, prop) {
+        ensureCacheConfig();
+        return Object.getOwnPropertyDescriptor(proxyTarget, prop);
+    },
+});

package/src/config/database.d.ts

@@ -3,81 +3,39 @@
  * Database connections and pooling settings
  * Sealed namespace for immutability
  */
-import type { DatabaseConfigShape, DatabaseConnectionConfig } from './type';
-export declare const databaseConfig: Readonly<{
-    /**
-     * Default database connection
-     */
+import type { DatabaseConfigShape, DatabaseConnectionConfig, DatabaseConnections } from './type';
+export type DatabaseConfigOverrides = Partial<{
     default: string;
-    /**
-     * Database connections
-     */
-    connections: {
-        sqlite: {
-            driver: "sqlite";
-            database: string;
-            migrations: string;
-        };
-        d1: {
-            driver: "d1";
-        };
-        'd1-remote': {
-            driver: "d1-remote";
-        };
-        postgresql: {
-            driver: "postgresql";
-            host: string;
-            port: number;
-            database: string;
-            username: string;
-            password: string;
-            ssl: boolean;
-            pooling: {
-                enabled: boolean;
-                min: number;
-                max: number;
-                idleTimeout: number;
-                connectionTimeout: number;
-            };
-        };
-        mysql: {
-            driver: "mysql";
-            host: string;
-            port: number;
-            database: string;
-            username: string;
-            password: string;
-            pooling: {
-                enabled: boolean;
-                min: number;
-                max: number;
-            };
-        };
-    };
-    /**
-     * Get current connection config
-     */
-    getConnection(this: DatabaseConfigShape): DatabaseConnectionConfig;
-    /**
-     * Enable query logging
-     */
+    connections: DatabaseConnections;
     logging: {
         enabled: boolean;
         level: string;
     };
-    /**
-     * Migration settings
-     */
     migrations: {
         directory: string;
         extension: string;
     };
-    /**
-     * Seeding settings
-     */
     seeders: {
         directory: string;
     };
 }>;
-export type DatabaseConfig = typeof databaseConfig;
+declare const createDatabaseConfig: () => {
+    default: string;
+    connections: DatabaseConnections;
+    getConnection: (this: DatabaseConfigShape) => DatabaseConnectionConfig;
+    logging: {
+        enabled: boolean;
+        level: string;
+    };
+    migrations: {
+        directory: string;
+        extension: string;
+    };
+    seeders: {
+        directory: string;
+    };
+};
+export type DatabaseConfig = ReturnType<typeof createDatabaseConfig>;
+export declare const databaseConfig: DatabaseConfig;
+export {};
 //# sourceMappingURL=database.d.ts.map

package/src/config/database.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/config/database.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,mBAAmB,EACnB,wBAAwB,EAEzB,MAAM,cAAc,CAAC;AAkNtB,eAAO,MAAM,cAAc;IAzCzB;;OAEG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;OAEG;wBACiB,mBAAmB,GAAG,wBAAwB;IAIlE;;OAEG;;;;;IAMH;;OAEG;;;;;IAMH;;OAEG;;;;EAMyD,CAAC;AAC/D,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC"}
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/config/database.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EACV,mBAAmB,EACnB,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,cAAc,CAAC;AAGtB,MAAM,MAAM,uBAAuB,GAAG,OAAO,CAAC;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,mBAAmB,CAAC;IACjC,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,UAAU,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IACrD,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAChC,CAAC,CAAC;AA0LH,QAAA,MAAM,oBAAoB,QAAO;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,mBAAmB,CAAC;IACjC,aAAa,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,wBAAwB,CAAC;IACvE,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,UAAU,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IACrD,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAyEhC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAqBrE,eAAO,MAAM,cAAc,EAAE,cAY3B,CAAC"}

package/src/config/database.js

@@ -3,6 +3,7 @@
  * Database connections and pooling settings
  * Sealed namespace for immutability
  */
+import { StartupConfigFile, StartupConfigFileRegistry } from '../runtime/StartupConfigFileRegistry.js';
 import { Env } from './env.js';
 import { ErrorFactory } from '../exceptions/ZintrustError.js';
 const isNodeProcess = () => {
@@ -94,6 +95,13 @@ const resolveDefaultSqliteDatabasePath = () => {
 const hasOwn = (obj, key) => {
     return Object.hasOwn(obj, key);
 };
+const parseReadHosts = (raw) => {
+    const list = String(raw ?? '')
+        .split(',')
+        .map((v) => v.trim())
+        .filter((v) => v.length > 0);
+    return list.length > 0 ? list : undefined;
+};
 const getDefaultConnection = (connections) => {
     const envSelectedRaw = Env.get('DB_CONNECTION', '');
     const value = String(envSelectedRaw ?? '').trim();
@@ -138,6 +146,7 @@ const connections = {
         username: Env.DB_USERNAME_POSTGRESQL,
         password: Env.DB_PASSWORD_POSTGRESQL,
         ssl: Env.getBool('DB_SSL', false),
+        readHosts: parseReadHosts(Env.DB_READ_HOSTS_POSTGRESQL),
         pooling: {
             enabled: Env.getBool('DB_POOLING', true),
             min: Env.getInt('DB_POOL_MIN', 5),
@@ -153,47 +162,106 @@ const connections = {
         database: Env.DB_DATABASE,
         username: Env.DB_USERNAME,
         password: Env.DB_PASSWORD,
+        readHosts: parseReadHosts(Env.DB_READ_HOSTS),
         pooling: {
             enabled: Env.getBool('DB_POOLING', true),
             min: Env.getInt('DB_POOL_MIN', 5),
             max: Env.getInt('DB_POOL_MAX', 20),
         },
     },
-};
-const databaseConfigObj = {
-    /**
-     * Default database connection
-     */
-    default: getDefaultConnection(connections),
-    /**
-     * Database connections
-     */
-    connections,
-    /**
-     * Get current connection config
-     */
-    getConnection() {
-        return getDatabaseConnection(this);
+    sqlserver: {
+        driver: 'sqlserver',
+        host: Env.DB_HOST_MSSQL,
+        port: Env.DB_PORT_MSSQL,
+        database: Env.DB_DATABASE_MSSQL,
+        username: Env.DB_USERNAME_MSSQL,
+        password: Env.DB_PASSWORD_MSSQL,
+        readHosts: parseReadHosts(Env.DB_READ_HOSTS_MSSQL),
     },
-    /**
-     * Enable query logging
-     */
-    logging: {
+};
+const createDatabaseConfig = () => {
+    const overrides = StartupConfigFileRegistry.get(StartupConfigFile.Database) ?? {};
+    const mergedConnections = {
+        ...connections,
+        ...overrides.connections,
+    };
+    const baseLogging = {
         enabled: Env.getBool('DB_LOG_QUERIES', Env.DEBUG),
         level: Env.get('DB_LOG_LEVEL', 'debug'),
-    },
-    /**
-     * Migration settings
-     */
-    migrations: {
+    };
+    const baseMigrations = {
         directory: 'database/migrations',
         extension: Env.get('DB_MIGRATION_EXT', '.ts'),
-    },
-    /**
-     * Seeding settings
-     */
-    seeders: {
+    };
+    const baseSeeders = {
         directory: 'database/seeders',
-    },
+    };
+    const mergedDefault = typeof overrides.default === 'string' && overrides.default.trim() !== ''
+        ? overrides.default.trim()
+        : getDefaultConnection(mergedConnections);
+    const databaseConfigObj = {
+        /**
+         * Default database connection
+         */
+        default: mergedDefault,
+        /**
+         * Database connections
+         */
+        connections: mergedConnections,
+        /**
+         * Get current connection config
+         */
+        getConnection() {
+            return getDatabaseConnection(this);
+        },
+        /**
+         * Enable query logging
+         */
+        logging: {
+            ...baseLogging,
+            ...overrides.logging,
+        },
+        /**
+         * Migration settings
+         */
+        migrations: {
+            ...baseMigrations,
+            ...overrides.migrations,
+        },
+        /**
+         * Seeding settings
+         */
+        seeders: {
+            ...baseSeeders,
+            ...overrides.seeders,
+        },
+    };
+    return Object.freeze(databaseConfigObj);
+};
+let cached = null;
+const proxyTarget = {};
+const ensureDatabaseConfig = () => {
+    if (cached)
+        return cached;
+    cached = createDatabaseConfig();
+    try {
+        Object.defineProperties(proxyTarget, Object.getOwnPropertyDescriptors(cached));
+    }
+    catch {
+        // best-effort
+    }
+    return cached;
 };
-export const databaseConfig = Object.freeze(databaseConfigObj);
+export const databaseConfig = new Proxy(proxyTarget, {
+    get(_target, prop) {
+        return ensureDatabaseConfig()[prop];
+    },
+    ownKeys() {
+        ensureDatabaseConfig();
+        return Reflect.ownKeys(proxyTarget);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+        ensureDatabaseConfig();
+        return Object.getOwnPropertyDescriptor(proxyTarget, prop);
+    },
+});

package/src/config/env.d.ts

@@ -28,6 +28,12 @@ export declare const Env: Readonly<{
     DB_USERNAME_POSTGRESQL: string;
     DB_PASSWORD_POSTGRESQL: string;
     DB_READ_HOSTS_POSTGRESQL: string;
+    DB_HOST_MSSQL: string;
+    DB_PORT_MSSQL: number;
+    DB_DATABASE_MSSQL: string;
+    DB_USERNAME_MSSQL: string;
+    DB_PASSWORD_MSSQL: string;
+    DB_READ_HOSTS_MSSQL: string;
     D1_DATABASE_ID: string;
     KV_NAMESPACE_ID: string;
     D1_REMOTE_URL: string;

package/src/config/env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/config/env.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA+CH,eAAO,MAAM,GAAG;eA/BE,MAAM,iBAAiB,MAAM,KAAG,MAAM;kBAMnC,MAAM,iBAAiB,MAAM,KAAG,MAAM;mBASrC,MAAM,iBAAiB,OAAO,KAAG,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA4GP,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO;;;;;;;;;EAkCxF,CAAC"}
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/config/env.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA+CH,eAAO,MAAM,GAAG;eA/BE,MAAM,iBAAiB,MAAM,KAAG,MAAM;kBAMnC,MAAM,iBAAiB,MAAM,KAAG,MAAM;mBASrC,MAAM,iBAAiB,OAAO,KAAG,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAoHP,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO;;;;;;;;;EAkCxF,CAAC"}

package/src/config/env.js

@@ -78,6 +78,13 @@ export const Env = Object.freeze({
     DB_USERNAME_POSTGRESQL: get('DB_USERNAME_POSTGRESQL', 'postgres'),
     DB_PASSWORD_POSTGRESQL: get('DB_PASSWORD_POSTGRESQL', ''),
     DB_READ_HOSTS_POSTGRESQL: get('DB_READ_HOSTS_POSTGRESQL', ''),
+    // SQL Server (MSSQL) specific configuration
+    DB_HOST_MSSQL: get('DB_HOST_MSSQL', get('DB_HOST', 'localhost')),
+    DB_PORT_MSSQL: getInt('DB_PORT_MSSQL', 1433),
+    DB_DATABASE_MSSQL: get('DB_DATABASE_MSSQL', 'zintrust'),
+    DB_USERNAME_MSSQL: get('DB_USERNAME_MSSQL', 'sa'),
+    DB_PASSWORD_MSSQL: get('DB_PASSWORD_MSSQL', ''),
+    DB_READ_HOSTS_MSSQL: get('DB_READ_HOSTS_MSSQL', ''),
     // Cloudflare
     D1_DATABASE_ID: get('D1_DATABASE_ID'),
     KV_NAMESPACE_ID: get('KV_NAMESPACE_ID'),

package/src/config/index.d.ts

@@ -31,62 +31,16 @@ export declare const config: Readonly<{
         readonly maxBodySize: string;
         readonly getSafeEnv: () => NodeJS.ProcessEnv;
     }>;
-    readonly broadcast: Readonly<{
-        readonly default: string;
-        readonly drivers: {
-            readonly inmemory: import("./type").InMemoryBroadcastDriverConfig;
-            readonly pusher: import("./type").PusherBroadcastDriverConfig;
-            readonly redis: import("./type").RedisBroadcastDriverConfig;
-            readonly redishttps: import("./type").RedisHttpsBroadcastDriverConfig;
-        };
-        readonly getDriverName: () => string;
-        readonly getDriverConfig: (name?: string) => import("./type").KnownBroadcastDriverConfig;
-    }>;
-    readonly database: Readonly<{
+    readonly broadcast: {
         default: string;
-        connections: {
-            sqlite: {
-                driver: "sqlite";
-                database: string;
-                migrations: string;
-            };
-            d1: {
-                driver: "d1";
-            };
-            'd1-remote': {
-                driver: "d1-remote";
-            };
-            postgresql: {
-                driver: "postgresql";
-                host: string;
-                port: number;
-                database: string;
-                username: string;
-                password: string;
-                ssl: boolean;
-                pooling: {
-                    enabled: boolean;
-                    min: number;
-                    max: number;
-                    idleTimeout: number;
-                    connectionTimeout: number;
-                };
-            };
-            mysql: {
-                driver: "mysql";
-                host: string;
-                port: number;
-                database: string;
-                username: string;
-                password: string;
-                pooling: {
-                    enabled: boolean;
-                    min: number;
-                    max: number;
-                };
-            };
-        };
-        getConnection(this: import("./type").DatabaseConfigShape): import("./type").DatabaseConnectionConfig;
+        drivers: import("./type").BroadcastDrivers;
+        getDriverName: () => string;
+        getDriverConfig: (name?: string) => import("./type").KnownBroadcastDriverConfig;
+    };
+    readonly database: {
+        default: string;
+        connections: import("./type").DatabaseConnections;
+        getConnection: (this: import("./type").DatabaseConfigShape) => import("./type").DatabaseConnectionConfig;
         logging: {
             enabled: boolean;
             level: string;
@@ -98,33 +52,31 @@ export declare const config: Readonly<{
         seeders: {
             directory: string;
         };
-    }>;
-    readonly storage: Readonly<{
-        readonly default: string;
-        readonly drivers: import("./type").StorageDrivers;
-        getDriver(this: import("./type").StorageConfigRuntime): import("./type").StorageDriverConfig;
-        getDriverConfig(this: import("./type").StorageConfigRuntime, name?: string): import("./type").StorageDriverConfig;
-        readonly temp: {
+    };
+    readonly storage: import("./type").StorageConfigRuntime & {
+        getDriver: (this: import("./type").StorageConfigRuntime) => import("./type").StorageDriverConfig;
+        getDriverConfig: (this: import("./type").StorageConfigRuntime, name?: string) => import("./type").StorageDriverConfig;
+        temp: {
             path: string;
             maxAge: number;
         };
-        readonly uploads: {
+        uploads: {
             maxSize: string;
             allowedMimes: string;
             path: string;
         };
-        readonly backups: {
+        backups: {
             path: string;
             driver: string;
         };
-    }>;
-    readonly notification: Readonly<{
-        readonly default: string;
-        readonly drivers: import("./type").NotificationDrivers;
-        readonly providers: import("./type").NotificationProviders;
-        readonly getDriverName: () => string;
-        readonly getDriverConfig: (name?: string) => import("./type").KnownNotificationDriverConfig;
-    }>;
+    };
+    readonly notification: {
+        default: string;
+        drivers: import("./type").NotificationDrivers;
+        providers: import("./type").NotificationProviders;
+        getDriverName: () => string;
+        getDriverConfig: (name?: string) => import("./type").KnownNotificationDriverConfig;
+    };
     readonly security: Readonly<{
         readonly jwt: {
             readonly enabled: boolean;
@@ -252,73 +204,17 @@ export declare const config: Readonly<{
             readonly namespace: string;
         };
     }>;
-    readonly cache: Readonly<{
+    readonly cache: {
         default: string;
-        drivers: {
-            memory: {
-                driver: "memory";
-                ttl: number;
-            };
-            redis: {
-                driver: "redis";
-                host: string;
-                port: number;
-                ttl: number;
-            };
-            mongodb: {
-                driver: "mongodb";
-                uri: string;
-                db: string;
-                ttl: number;
-            };
-            kv: {
-                driver: "kv";
-                ttl: number;
-            };
-            'kv-remote': {
-                driver: "kv-remote";
-                ttl: number;
-            };
-        };
-        getDriver(name?: string): import("./type").CacheDriverConfig;
+        drivers: import("./type").CacheConfigInput["drivers"];
+        getDriver: (name?: string) => import("./type").CacheDriverConfig;
         keyPrefix: string;
         ttl: number;
-    }>;
-    readonly queue: Readonly<{
+    };
+    readonly queue: {
         default: import("./type").QueueDriverName;
-        drivers: {
-            sync: {
-                driver: "sync";
-            };
-            database: {
-                driver: "database";
-                table: string;
-                connection: string;
-            };
-            redis: {
-                driver: "redis";
-                host: string;
-                port: number;
-                password: string;
-                database: number;
-            };
-            rabbitmq: {
-                driver: "rabbitmq";
-                host: string;
-                port: number;
-                username: string;
-                password: string;
-                vhost: string;
-            };
-            sqs: {
-                driver: "sqs";
-                key: string;
-                secret: string;
-                region: string;
-                queueUrl: string;
-            };
-        };
-        getDriver(): import("./type").QueueDriversConfig[import("./type").QueueDriverName];
+        drivers: import("./type").QueueDriversConfig;
+        getDriver: (this: import("./type").QueueConfigWithDrivers) => import("./type").QueueDriversConfig[import("./type").QueueDriverName];
         failed: {
             database: string;
             table: string;
@@ -329,7 +225,7 @@ export declare const config: Readonly<{
             backoff: number;
             workers: number;
         };
-    }>;
+    };
 }>;
 export type Config = typeof config;
 //# sourceMappingURL=index.d.ts.map

package/src/config/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAaH,OAAO,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,KAAK,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACtF,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWR,CAAC;AAEZ,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAaH,OAAO,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,KAAK,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACtF,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;8BAXgB,CAAA;;;;;;;;;;;;;;;;;;;;2EAAA,CAAC;;;;;;;;;;;;;;;;;;;;8BAD2B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAoBxD,CAAC;;;;;;;;;;;;;;;;;;;EAGE,CAAC;AAEZ,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC"}