@proventuslabs/nestjs-zod 1.1.0 → 1.2.0

package/README.md

@@ -1,10 +1,10 @@
 # @proventuslabs/nestjs-zod
 
-A collection of NestJS modules to integrate Zod into your application with enhanced configuration management and type safety.
+A collection of NestJS modules to integrate Zod v4 into your application with enhanced configuration management and type safety.
 
-## Features
+## ✨ Features
 
-- 🔧 **Zod-powered Configuration**: Type-safe configuration management using Zod schemas
+- 🔧 **Zod-powered Configuration**: Type-safe configuration management using Zod schemas (v4)
 - 🌍 **Environment Variable Support**: Automatic parsing and validation of environment variables
 - 📁 **Configuration Files**: Support for YAML configuration files
 - 🏗️ **Configurable Modules**: Enhanced NestJS configurable modules with Zod validation
@@ -12,61 +12,42 @@ A collection of NestJS modules to integrate Zod into your application with enhan
 - 🔄 **Merge Strategy**: Environment variables override configuration file values
 - 📝 **Descriptive Errors**: Enhanced error messages with schema descriptions
 
-## Installation
+## 📦 Installation
 
 ```bash
-npm install @proventuslabs/nestjs-zod
+npm install @proventuslabs/nestjs-zod zod
 ```
 
-## Peer Dependencies
-
-This package requires the following peer dependencies:
+**Peer Dependencies:**
 
 - `@nestjs/common` ^10.0.0 || ^11.0.0
 - `@nestjs/config` ^3.0.0 || ^4.0.0
-- `zod` ^3.0.0
-
-## Quick Start
+- `zod` ^3.25.0 || ^4.0.0
 
-### Configuration Management
+## 🎯 Quick Start
 
 ```typescript
-import { Module } from '@nestjs/common';
-import { ConfigModule } from '@nestjs/config';
-import { registerConfig, type ConfigType } from '@proventuslabs/nestjs-zod';
-import { z } from 'zod';
-
-// Define your configuration schema
+import { Module, Injectable } from "@nestjs/common";
+import { ConfigModule, ConfigService } from "@nestjs/config";
+import {
+  registerConfig,
+  type NamespacedConfigType,
+} from "@proventuslabs/nestjs-zod";
+import { z } from "zod";
+
+// Define configuration schema
 const appConfig = registerConfig(
-  'app',
+  "app",
   z.object({
-    port: z
-      .number()
-      .int()
-      .min(0)
-      .max(65535)
-      .default(3000)
-      .describe('The local HTTP port to bind the server to'),
-    host: z
-      .string()
-      .default('localhost')
-      .describe('The host to bind the server to'),
-    environment: z
-      .enum(['development', 'production', 'test'])
-      .default('development')
-      .describe('The application environment'),
-    apiKey: z
-      .string()
-      .describe('API key for external services'),
+    port: z.number().default(3000).describe("Server port"),
+    host: z.string().default("localhost").describe("Server host"),
+    apiKey: z.string().describe("API key for external services"),
   }),
   {
-    whitelistKeys: new Set(['API_KEY']), // Allow API_KEY without APP_ prefix
+    whitelistKeys: new Set(["API_KEY"]), // Allow API_KEY without APP_ prefix
   }
 );
 
-// Type inference
-type AppConfig = ConfigType<typeof appConfig>;
-
 @Module({
   imports: [
     ConfigModule.forRoot({
@@ -76,340 +57,203 @@ type AppConfig = ConfigType<typeof appConfig>;
   ],
 })
 export class AppModule {}
-```
-
-### Using Configuration
-
-```typescript
-import { Injectable } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { type NamespacedConfigType } from '@proventuslabs/nestjs-zod';
 
 @Injectable()
 export class AppService {
   constructor(
-    private configService: ConfigService<NamespacedConfigType<typeof appConfig>, true>
+    private configService: ConfigService<
+      NamespacedConfigType<typeof appConfig>,
+      true
+    >
   ) {}
 
-  getPort(): number {
-    return this.configService.get('app.port', { infer: true });
-  }
-
-  getHost(): string {
-    return this.configService.get('app.host', { infer: true });
+  getAppConfig() {
+    return {
+      port: this.configService.get("app.port", { infer: true }),
+      host: this.configService.get("app.host", { infer: true }),
+      apiKey: this.configService.get("app.apiKey", { infer: true }),
+    };
   }
 }
 ```
 
-## Configuration Sources
+## 🔧 Configuration and Options
 
-The package supports multiple configuration sources with a clear precedence order:
+It comes out of the box with the support for env variables and yaml files.
 
-1. **Environment Variables** (highest priority)
-2. **Configuration Files** (YAML)
-3. **Schema Defaults** (lowest priority)
+Priority order: **Environment Variables** > **YAML Files** > **Schema Defaults**
 
 ### Environment Variables
 
-Environment variables are automatically parsed and validated. Use the namespace prefix followed by underscores:
+Variables are automatically parsed using the namespace prefix:
 
 ```bash
-# For the 'app' namespace
+# Standard namespaced variables
 APP_PORT=8080
 APP_HOST=0.0.0.0
-APP_ENVIRONMENT=production
 
-# Nested configuration using double underscores
+# Nested objects using double underscores
 APP_DATABASE__HOST=localhost
 APP_DATABASE__PORT=5432
-APP_DATABASE__NAME=myapp
-```
-
-#### Whitelist Keys
-
-By default, only environment variables with the namespace prefix are processed. You can whitelist additional environment variables to bypass this restriction:
-
-```typescript
-const appConfig = registerConfig(
-  'app',
-  z.object({
-    port: z.number().default(3000),
-    apiKey: z.string().describe('API key from environment'),
-  }),
-  {
-    whitelistKeys: new Set(['API_KEY']), // Allow API_KEY without APP_ prefix
-  }
-);
-```
-
-This allows you to use environment variables like:
-```bash
-API_KEY=your-secret-key  # Will be mapped to app.apiKey
-APP_PORT=8080            # Standard namespaced variable
 ```
 
 ### Configuration Files
 
-Support for YAML configuration files via environment variables:
+Support for YAML files via environment variables:
 
 ```bash
-# Specify a configuration file
-CONFIG_FILE=./config/app.yaml
-
-# Or provide inline YAML content
-CONFIG_CONTENT="app:
-  port: 8080
-  host: 0.0.0.0
-  environment: production
-  database:
-    host: localhost
-    port: 5432
-    name: myapp"
+CONFIG_FILE=./config/app.yaml  # Load from file
+CONFIG_CONTENT="..."           # Inline YAML content
 ```
 
-Example `config/app.yaml`:
-
-```yaml
-app:
-  port: 8080
-  host: 0.0.0.0
-  environment: production
-  database:
-    host: localhost
-    port: 5432
-    name: myapp
-  redis:
-    host: localhost
-    port: 6379
-```
-
-## Configurable Modules
-
-Create type-safe configurable modules with Zod validation:
+### Schema defaults
 
 ```typescript
-import { Module } from '@nestjs/common';
-import { ZodConfigurableModuleBuilder } from '@proventuslabs/nestjs-zod';
-import { z } from 'zod';
-
-const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = new ZodConfigurableModuleBuilder(
+// Multiple configuration sources
+const dbConfig = registerConfig(
+  "database",
   z.object({
-    apiKey: z.string().min(1),
-    baseUrl: z.string().url().default('https://api.example.com'),
-    timeout: z.number().positive().default(5000),
+    host: z.string().default("localhost"),
+    port: z.number().default(5432),
+    ssl: z.boolean().default(false),
   })
-).build();
-
-@Module({
-  providers: [
-    {
-      provide: 'EXTERNAL_SERVICE',
-      useFactory: (options) => {
-        // options is fully typed and validated
-        return new ExternalService(options);
-      },
-      inject: [MODULE_OPTIONS_TOKEN],
-    },
-  ],
-  exports: ['EXTERNAL_SERVICE'],
-})
-export class ExternalServiceModule extends ConfigurableModuleClass {}
-```
-
-### Using Configurable Modules
-
-```typescript
-// Static configuration
-ExternalServiceModule.register({
-  apiKey: 'your-api-key',
-  baseUrl: 'https://custom-api.example.com',
-  timeout: 10000,
-});
-
-// Async configuration
-ExternalServiceModule.registerAsync({
-  useFactory: (configService: ConfigService) => ({
-    apiKey: configService.get('EXTERNAL_API_KEY'),
-    baseUrl: configService.get('EXTERNAL_BASE_URL'),
-    timeout: configService.get('EXTERNAL_TIMEOUT'),
-  }),
-  inject: [ConfigService],
-});
+);
 ```
 
-## API Reference
+## 📋 API Reference
 
 ### `registerConfig`
 
-Registers a configuration with the `ConfigModule.forFeature` for partial configuration under the provided namespace.
+Registers a type-safe configuration with automatic validation and environment variable parsing.
 
 ```typescript
-function registerConfig<N extends string, C extends ConfigObject, I extends JsonValue>(
-  namespace: ConfigNamespace<N>,
-  configSchema: ZodType<C, ZodTypeDef, I>,
-  options?: {
-    whitelistKeys?: Set<string>;
-    variables?: Record<string, string | undefined>;
-  }
-): ReturnType<typeof registerAs<C>> & { NAMESPACE: N }
+registerConfig(namespace, zodSchema, options?)
 ```
 
 **Parameters:**
-- `namespace`: The namespace for the configuration (camelCase)
-- `configSchema`: Zod schema for validation
-- `options`: Configuration options
-  - `whitelistKeys`: Set of environment variable names to allow without namespace prefix
-  - `variables`: Environment variables object (defaults to `process.env`)
 
-**Returns:** A configuration provider that can be used with `ConfigModule.forRoot()`
+- `namespace`: Configuration namespace (camelCase)
+- `zodSchema`: Zod schema for validation
+- `options.whitelistKeys`: Environment variables to allow without namespace prefix
+
+#### Whitelist Keys
+
+By default, only environment variables with the namespace prefix are processed. You can whitelist additional environment variables to bypass this restriction:
 
-**Example:**
 ```typescript
 const appConfig = registerConfig(
-  'app',
+  "app",
   z.object({
     port: z.number().default(3000),
-    apiKey: z.string(),
-    database: z.object({
-      host: z.string().default('localhost'),
-      port: z.number().default(5432),
-    }),
+    apiKey: z.string().describe("API key from environment"),
   }),
   {
-    whitelistKeys: new Set(['API_KEY', 'DATABASE_URL']),
+    whitelistKeys: new Set(["API_KEY"]), // Allow API_KEY without APP_ prefix
   }
 );
 ```
 
-### `ConfigType<T>`
-
-Extracts the inferred type from a configuration schema.
-
-```typescript
-type ConfigType<T extends (...args: unknown[]) => unknown> = NestConfigType<T>;
+```bash
+API_KEY=your-secret-key  # Will be mapped to app.apiKey
+APP_PORT=8080            # Standard namespaced variable
 ```
 
-### `NamespacedConfigType<T>`
+### `ZodConfigurableModuleBuilder`
 
-Extracts the namespaced configuration type.
+Create type-safe configurable modules with Zod validation:
 
 ```typescript
-type NamespacedConfigType<R> = {
-  [K in R["NAMESPACE"]]: NestConfigType<R>;
-};
-```
-
-### `ZodConfigurableModuleBuilder`
+import { Module } from "@nestjs/common";
+import { ZodConfigurableModuleBuilder } from "@proventuslabs/nestjs-zod";
+import { z } from "zod";
+
+const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } =
+  new ZodConfigurableModuleBuilder(
+    z.object({
+      apiKey: z.string(),
+      baseUrl: z.string().url().default("https://api.example.com"),
+      timeout: z.number().default(5000),
+    })
+  ).build();
 
-Builder class for creating configurable modules with Zod validation.
+@Module({
+  providers: [
+    {
+      provide: "EXTERNAL_SERVICE",
+      useFactory: (options) => new ExternalService(options), // fully typed
+      inject: [MODULE_OPTIONS_TOKEN],
+    },
+  ],
+})
+export class ExternalServiceModule extends ConfigurableModuleClass {}
 
-```typescript
-class ZodConfigurableModuleBuilder<
-  ModuleOptions,
-  ModuleOptionsInput = unknown,
-  StaticMethodKey extends string = string,
-  FactoryClassMethodKey extends string = string,
-  ExtraModuleDefinitionOptions = object
->
+// Usage
+ExternalServiceModule.register({
+  apiKey: "your-key",
+  timeout: 10000,
+});
 ```
 
-## Error Handling
+Offers identical API to the standard NestJS `ConfigurableModuleBuilder`, consult [their docs](https://docs.nestjs.com/fundamentals/dynamic-modules#configurable-module-builder) for usage.
+
+## 🚨 Error Handling
 
-The package provides enhanced error messages that include:
+Enhanced validation errors with detailed information:
 
-- Schema descriptions when available
+- Schema descriptions and validation paths
 - Original environment variable names
-- Detailed validation error paths
-- Helpful suggestions for fixing configuration issues
+- Uses Zod errors under the hood
 
-Example error output:
+## 🎭 Types
 
-```
-TypeError: Configuration validation failed for 'app' namespace
+```typescript
+// Configuration type extraction
+type AppConfig = ConfigType<typeof appConfig>;
 
-  • app.port: Expected number, received string
-    Description: The local HTTP port to bind the server to
-    Environment Variable: APP_PORT
+// Namespaced configuration for ConfigService
+type NamespacedConfig = NamespacedConfigType<typeof appConfig>;
 
-  • app.database.host: Required
-    Description: Database host address
-    Environment Variable: APP_DATABASE__HOST
+// Usage with ConfigService
+constructor(
+  private configService: ConfigService<NamespacedConfig, true>,
+  @Inject(appConfig.KEY)
+  private appConfigObject: AppConfig,
+) {}
 ```
 
-## Examples
+## ⚡ Best Practices
 
-### Basic Configuration with Whitelist Keys
+- Use descriptive schema descriptions for better error messages
+- Leverage whitelist keys for common environment variables
+- Combine multiple configuration namespaces for organized settings
+- Utilize schema defaults to reduce required environment variables
 
 ```typescript
-import { Module } from '@nestjs/common';
-import { ConfigModule } from '@nestjs/config';
-import { registerConfig, type ConfigType } from '@proventuslabs/nestjs-zod';
-import { z } from 'zod';
-
-// Configuration with whitelist support
+// ✅ Good: Descriptive and well-structured
 const appConfig = registerConfig(
-  'app',
+  "app",
   z.object({
-    port: z.number().default(3000),
-    host: z.string().default('localhost'),
-    apiKey: z.string().describe('External API key'),
-    database: z.object({
-      url: z.string().describe('Database connection URL'),
-      poolSize: z.number().default(10),
-    }),
+    port: z.number().default(3000).describe("HTTP server port"),
+    apiKey: z.string().describe("Third-party API authentication key"),
   }),
-  {
-    whitelistKeys: new Set(['API_KEY', 'DATABASE_URL']),
-  }
+  { whitelistKeys: new Set(["API_KEY"]) }
 );
 
-@Module({
-  imports: [
-    ConfigModule.forRoot({
-      isGlobal: true,
-      load: [appConfig],
-    }),
-  ],
-})
-export class AppModule {}
+// ✅ Good: Multiple namespaces for organization
+const dbConfig = registerConfig("database", dbSchema);
+const redisConfig = registerConfig("redis", redisSchema);
 ```
 
-With this configuration, you can use environment variables like:
-```bash
-# Standard namespaced variables
-APP_PORT=8080
-APP_HOST=0.0.0.0
+## 🤝 Contributing
 
-# Whitelisted variables (no namespace prefix required)
-API_KEY=your-secret-key
-DATABASE_URL=postgresql://user:pass@localhost:5432/db
-```
+We welcome contributions! Please see our [Contributing Guidelines](../../CONTRIBUTING.md) for details.
 
-### Advanced Configuration with Multiple Sources
+## 📄 License
 
-```typescript
-const databaseConfig = registerConfig(
-  'database',
-  z.object({
-    host: z.string().default('localhost'),
-    port: z.number().default(5432),
-    name: z.string(),
-    username: z.string(),
-    password: z.string(),
-    ssl: z.boolean().default(false),
-  }),
-  {
-    whitelistKeys: new Set(['DB_HOST', 'DB_PORT', 'DB_NAME']),
-  }
-);
-```
-
-See the [examples](./examples) directory for complete working examples.
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
+This project is licensed under the MIT License - see the [LICENSE](../../LICENSE) file for details.
 
-## License
+## 🔗 Links
 
-This project is licensed under the MIT License - see the [LICENSE](../../LICENSE) file for details.
+- [ProventusLabs](https://proventuslabs.com)
+- [NestJS Documentation](https://nestjs.com)
+- [Zod Documentation](https://zod.dev)

package/dist/config/config.d.ts

@@ -1,6 +1,6 @@
 import { type ConfigObject, type ConfigType as NestConfigType } from "@nestjs/config";
 import type { CamelCase, JsonValue } from "type-fest";
-import { type ZodType, type ZodTypeDef } from "zod";
+import { type $ZodType } from "zod/v4/core";
 /**
  * Simple type alias for config namespace.
  */
@@ -51,7 +51,7 @@ export type NamespacedConfigType<R extends ReturnType<typeof registerConfig<stri
  * export type AppConfigNamespaced = NamespacedConfigType<typeof appConfig>;
  * export type AppConfig = ConfigType<typeof appConfig>;
  */
-export declare function registerConfig<N extends string, C extends ConfigObject, I extends JsonValue>(namespace: ConfigNamespace<N>, configSchema: ZodType<C, ZodTypeDef, I>, options?: {
+export declare function registerConfig<N extends string, C extends ConfigObject, I extends JsonValue | unknown>(namespace: ConfigNamespace<N>, configSchema: $ZodType<C, I>, options?: {
     whitelistKeys?: Set<string>;
     variables?: Record<string, string | undefined>;
 }): import("@nestjs/config").ConfigFactory<C> & import("@nestjs/config").ConfigFactoryKeyHost<C | Promise<C>> & {

package/dist/config/config.js

@@ -7,7 +7,7 @@ exports.registerConfig = registerConfig;
 const node_process_1 = __importDefault(require("node:process"));
 const config_1 = require("@nestjs/config");
 const lodash_1 = require("lodash");
-const zod_1 = require("zod");
+const core_1 = require("zod/v4/core");
 const internal_1 = require("../internal");
 /**
  * Registers a config with the `ConfigModule.forFeature` for partial configuration under the provided namespace.
@@ -40,13 +40,10 @@ function registerConfig(namespace, configSchema, options = {}) {
     const service = (0, config_1.registerAs)(namespace, async () => {
         const [decodedEnv, envKeys] = (0, internal_1.decodeVariables)(variables, namespace, whitelistKeys);
         const decodedConfig = (0, internal_1.decodeConfig)(variables.CONFIG_CONTENT, variables.CONFIG_FILE);
-        const namespacedSchema = zod_1.z.object({
-            [namespace]: configSchema,
-        });
-        const parsedConfig = await namespacedSchema.safeParseAsync((0, lodash_1.merge)({ [namespace]: {} }, decodedConfig, decodedEnv));
+        const parsedConfig = await (0, core_1.safeParseAsync)(configSchema, (0, lodash_1.merge)({}, decodedConfig[namespace], decodedEnv[namespace]));
         if (!parsedConfig.success)
-            throw (0, internal_1.zodErrorToTypeError)(parsedConfig.error, namespacedSchema, namespace, envKeys);
-        const config = parsedConfig.data[namespace];
+            throw new TypeError(`Invalid config for "${namespace}":\n${(0, internal_1.typifyError)(configSchema, parsedConfig.error, namespace, envKeys)}`, { cause: parsedConfig.error });
+        const config = parsedConfig.data;
         return config;
     });
     // we add the namespace to the object itself for runtime access too

package/dist/config/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":";;;;;AAkEA,wCAgCC;AAlGD,gEAAmC;AAEnC,2CAAkG;AAElG,mCAA+B;AAE/B,6BAAuD;AAEvD,0CAAiF;AAgCjF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAAgB,cAAc,CAC7B,SAA6B,EAC7B,YAAuC,EACvC,UAGI,EAAE;IAEN,MAAM,EAAE,SAAS,GAAG,sBAAO,CAAC,GAAG,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC;IAE3D,MAAM,OAAO,GAAG,IAAA,mBAAU,EAAC,SAAS,EAAE,KAAK,IAAI,EAAE;QAChD,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,GAAG,IAAA,0BAAe,EAAC,SAAS,EAAE,SAAS,EAAE,aAAa,CAAC,CAAC;QACnF,MAAM,aAAa,GAAG,IAAA,uBAAY,EAAC,SAAS,CAAC,cAAc,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;QAEpF,MAAM,gBAAgB,GAAG,OAAC,CAAC,MAAM,CAAC;YACjC,CAAC,SAAS,CAAC,EAAE,YAAY;SACzB,CAAC,CAAC;QACH,MAAM,YAAY,GAAG,MAAM,gBAAgB,CAAC,cAAc,CACzD,IAAA,cAAK,EAAC,EAAE,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE,aAAa,EAAE,UAAU,CAAC,CACrD,CAAC;QACF,IAAI,CAAC,YAAY,CAAC,OAAO;YACxB,MAAM,IAAA,8BAAmB,EAAC,YAAY,CAAC,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QACrF,MAAM,MAAM,GAAM,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAE/C,OAAO,MAAM,CAAC;IACf,CAAC,CAAwD,CAAC;IAE1D,mEAAmE;IACnE,OAAO,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,WAAW,EAAE;QAClD,KAAK,EAAE,SAAS;QAChB,QAAQ,EAAE,KAAK;KACf,CAAC,CAAC;AACJ,CAAC;AAED,kBAAe,cAAc,CAAC"}
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":";;;;;AAkEA,wCAqCC;AAvGD,gEAAmC;AAEnC,2CAAkG;AAElG,mCAA+B;AAE/B,sCAA4D;AAE5D,0CAAyE;AAgCzE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAAgB,cAAc,CAK7B,SAA6B,EAC7B,YAA4B,EAC5B,UAGI,EAAE;IAEN,MAAM,EAAE,SAAS,GAAG,sBAAO,CAAC,GAAG,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC;IAE3D,MAAM,OAAO,GAAG,IAAA,mBAAU,EAAC,SAAS,EAAE,KAAK,IAAI,EAAE;QAChD,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,GAAG,IAAA,0BAAe,EAAC,SAAS,EAAE,SAAS,EAAE,aAAa,CAAC,CAAC;QACnF,MAAM,aAAa,GAAG,IAAA,uBAAY,EAAC,SAAS,CAAC,cAAc,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;QAEpF,MAAM,YAAY,GAAG,MAAM,IAAA,qBAAc,EACxC,YAAY,EACZ,IAAA,cAAK,EAAC,EAAE,EAAE,aAAa,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC,CAC1D,CAAC;QACF,IAAI,CAAC,YAAY,CAAC,OAAO;YACxB,MAAM,IAAI,SAAS,CAClB,uBAAuB,SAAS,OAAO,IAAA,sBAAW,EAAC,YAAY,EAAE,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAC1G,EAAE,KAAK,EAAE,YAAY,CAAC,KAAK,EAAE,CAC7B,CAAC;QACH,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC;QAEjC,OAAO,MAAM,CAAC;IACf,CAAC,CAAwD,CAAC;IAE1D,mEAAmE;IACnE,OAAO,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,WAAW,EAAE;QAClD,KAAK,EAAE,SAAS;QAChB,QAAQ,EAAE,KAAK;KACf,CAAC,CAAC;AACJ,CAAC;AAED,kBAAe,cAAc,CAAC"}

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./config/config";
+export { typifyError } from "./internal";
 export * from "./module/module";

package/dist/index.js

@@ -14,6 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.typifyError = void 0;
 __exportStar(require("./config/config"), exports);
+var internal_1 = require("./internal");
+Object.defineProperty(exports, "typifyError", { enumerable: true, get: function () { return internal_1.typifyError; } });
 __exportStar(require("./module/module"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kDAAgC;AAChC,kDAAgC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,kDAAgC;AAChC,uCAAyC;AAAhC,uGAAA,WAAW,OAAA;AACpB,kDAAgC"}