@sentzunhat/zacatl 0.0.14 → 0.0.21

package/README.md

@@ -1,295 +1,380 @@
-# Zacatl Microservice Framework
+# Zacatl Framework
 
 [![npm version](https://img.shields.io/npm/v/@sentzunhat/zacatl.svg)](https://www.npmjs.com/package/@sentzunhat/zacatl)
+[![npm downloads](https://img.shields.io/npm/dm/@sentzunhat/zacatl.svg)](https://www.npmjs.com/package/@sentzunhat/zacatl)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![TypeScript](https://img.shields.io/badge/%3C%2F%3E-TypeScript-%230074c1.svg)](https://www.typescriptlang.org/)
+[![TypeScript](https://img.shields.io/badge/%3C%2F%3E-TypeScript-3178c6.svg)](https://www.typescriptlang.org/)
+[![Node.js 24+](https://img.shields.io/badge/Node.js-24%2B-brightgreen.svg)](https://nodejs.org/)
+[![Tests: 161](https://img.shields.io/badge/Tests-161-blue.svg)](#testing)
+[![Coverage: 79%](https://img.shields.io/badge/Coverage-79%25-brightgreen.svg)](#testing)
 
-A modular, high-performance TypeScript microservice framework for Node.js, featuring layered architecture, dependency injection, and robust validation for building scalable APIs and distributed systems.
+**Production-ready TypeScript framework for building scalable microservices, APIs, and distributed systems.**
 
-## Table of Contents
+Zacatl enforces clean, layered architecture with dependency injection, validation, and comprehensive error handling—designed for both human developers and AI agents to collaborate effectively.
 
-- [Overview](#overview)
-- [Key Features](#key-features)
-- [Installation](#installation)
-- [Quick Start](#quick-start)
-- [Project Structure](#project-structure)
-- [Core Concepts](#core-concepts)
-- [Configuration](#configuration)
-- [Testing](#testing)
-- [Contributing](#contributing)
-- [Documentation](#documentation)
-- [License](#license)
+## ✨ Key Features
 
-## Overview
+- **🏗️ Layered/Hexagonal Architecture** - Clean separation with Application, Domain, Infrastructure, and Platform layers
+- **💉 Dependency Injection** - Built-in DI container using `tsyringe`
+- **✅ Type-Safe Validation** - Full Zod schema support for requests/responses
+- **🛡️ Structured Error Handling** - 7 custom error types with correlation IDs
+- **🗄️ Pluggable ORM Adapters** - Sequelize, Mongoose, or build your own
+- **🌐 Multi-Language Support** - Pluggable i18n with filesystem/memory adapters
+- **🔌 Adapter Pattern** - Easy integration with any database or service
+- **🧪 Comprehensive Testing** - 161 tests, 79% coverage, Vitest
+- **⚡ Runtime Detection** - Works with Node.js 22+ and Bun
+- **📝 Production Ready** - Structured logging, monitoring, and error tracking
 
-Zacatl is a TypeScript-first microservice framework that enforces clean, layered (hexagonal) architecture with strict separation of concerns. It's designed for rapid development of robust APIs and distributed systems, with built-in support for dependency injection, validation, and seamless collaboration between human and AI contributors.
+## 📖 Documentation
 
-## Key Features
+- **[Full Documentation Index](./docs/INDEX.md)** - Complete guide and reference
+- **[5-Minute Quick Start](./docs/getting-started/quickstart-5min.md)** - Get up and running fast
+- **[Framework Overview](./docs/architecture/framework-overview.md)** - Architecture and concepts
+- **[Installation Guide](./docs/getting-started/INSTALLATION.md)** - Setup instructions
+- **[Testing Guide](./docs/testing/README.md)** - How to test your services
+- **[Examples](./docs/examples/README.md)** - Practical patterns
+- **[API Reference](./docs/api/README.md)** - Core APIs
 
-- **🏗️ Layered Architecture**: Clean separation with Application, Domain, Infrastructure, and Platform layers
-- **💉 Dependency Injection**: Built-in DI container using `tsyringe` for better modularity
-- **⚡ High Performance**: Built on Fastify for maximum speed and efficiency
-- **🔍 Type Safety**: Full TypeScript support with strict typing and generics
-- **✅ Validation**: Request/response validation using Zod schemas
-- **🧪 Testing**: Comprehensive testing with Vitest and clear test structure
-- **📊 MongoDB Support**: Built-in repository pattern with Mongoose integration
-- **🌐 Internationalization**: Multi-language support with i18n
-- **🚀 Production Ready**: Error handling, logging, and monitoring built-in
+## Ethical Use (Non-binding)
 
-## Installation
+Zacatl is MIT-licensed (permissive). Please don’t use it to harm people.
 
-Install Zacatl using npm:
+## 🚀 Quick Start
+
+### Install
 
 ```bash
 npm install @sentzunhat/zacatl
 ```
 
-Or with yarn:
+## 📦 Import Shortcuts (v0.0.21+)
 
-```bash
-yarn add @sentzunhat/zacatl
-```
+```typescript
+// Short imports for better DX
+import { BaseRepository, ORMType } from "@sentzunhat/zacatl/infrastructure";
+import { CustomError } from "@sentzunhat/zacatl/errors";
+import { loadConfig } from "@sentzunhat/zacatl/config";
 
-## Quick Start
+// Or full path (still works)
+import { BaseRepository } from "@sentzunhat/zacatl/build/service/architecture/infrastructure/repositories/abstract";
+```
 
-Here's a minimal example to get you started:
+### Hello World HTTP Service
 
 ```typescript
 import Fastify from "fastify";
-import { MicroService } from "@sentzunhat/zacatl";
+import { Service } from "@sentzunhat/zacatl";
 
-const fastifyApp = Fastify();
+const fastify = Fastify();
 
-const microservice = new MicroService({
+const service = new Service({
   architecture: {
     application: {
-      entryPoints: {
-        rest: {
-          hookHandlers: [], // Add hook handler classes
-          routeHandlers: [], // Add route handler classes
-        },
-      },
+      entryPoints: { rest: { hookHandlers: [], routeHandlers: [] } },
     },
-    domain: { providers: [] }, // Add domain provider classes
-    infrastructure: { repositories: [] }, // Add repository classes
-    service: {
-      name: "my-service",
-      server: {
-        type: "SERVER",
-        vendor: "FASTIFY",
-        instance: fastifyApp,
-      },
-      databases: [
-        // Example for MongoDB:
-        // {
-        //   vendor: "MONGOOSE",
-        //   instance: new Mongoose(),
-        //   connectionString: "mongodb://localhost/mydb",
-        // }
-      ],
+    domain: { providers: [] },
+    infrastructure: { repositories: [] },
+    server: {
+      name: "hello-service",
+      server: { type: "SERVER", vendor: "FASTIFY", instance: fastify },
     },
   },
 });
 
-await microservice.start({ port: 9000 });
+await service.start({ port: 3000 });
+```
+
+### CLI / Desktop Application
+
+```typescript
+import { Service, resolveDependency } from "@sentzunhat/zacatl";
+
+class MyService {
+  doSomething = async () => console.log("Hello from CLI!");
+}
+
+const service = new Service({
+  architecture: {
+    domain: { providers: [MyService] },
+  },
+});
+
+await service.start();
+const myService = resolveDependency<MyService>("MyService");
+await myService.doSomething();
 ```
 
-For a complete example with route handlers, see our [examples](./examples) directory.
+## 🏗️ Architecture Layers
 
-## Project Structure
+Zacatl implements **layered (hexagonal) architecture**:
 
 ```
-src/
-├── configuration.ts         # App configuration and environment settings
-├── logs.ts                  # Structured logging with Pino
-├── optionals.ts             # Optional utility types and helpers
-├── error/                   # Custom error classes (BadRequest, NotFound, etc.)
-├── locales/                 # Internationalization files (en.json, fr.json)
-├── micro-service/
-│   └── architecture/
-│       ├── application/     # HTTP entry points, validation, route handlers
-│       ├── domain/          # Business logic, models, services (pure)
-│       ├── infrastructure/  # Database repositories, external adapters
-│       └── platform/        # Service orchestration, DI setup, startup
-└── utils/                   # Utility functions (base64, hmac, etc.)
-
-test/
-└── unit/                    # Unit tests mirroring src/ structure
+┌─────────────────────────────────────────┐
+│        Application Layer                │  HTTP handlers, validation, routes
+├─────────────────────────────────────────┤
+│        Domain Layer                     │  Business logic, services, models
+├─────────────────────────────────────────┤
+│        Infrastructure Layer             │  Repositories, database adapters
+├─────────────────────────────────────────┤
+│        Platform Layer                   │  DI container, service startup
+└─────────────────────────────────────────┘
+```
+
+Each layer has a single responsibility and strict dependencies flow inward.
+
+## 💾 Database Adapters
+
+### Sequelize
+
+```typescript
+import { Sequelize } from "sequelize";
+import { SequelizeAdapter } from "@sentzunhat/zacatl/adapters";
+
+const sequelize = new Sequelize("postgresql://user:pass@localhost/db");
+
+const service = new Service({
+  architecture: {
+    server: {
+      databases: [
+        {
+          vendor: "SEQUELIZE",
+          instance: sequelize,
+        },
+      ],
+    },
+  },
+});
 ```
 
-### Layer Responsibilities
+### MongoDB (Mongoose)
+
+```typescript
+import mongoose from "mongoose";
 
-- **Application Layer**: Handles HTTP requests, validation, and delegates to domain logic
-- **Domain Layer**: Contains pure business logic, models, and services (no infrastructure dependencies)
-- **Infrastructure Layer**: Manages persistence (MongoDB repositories) and external integrations
-- **Platform Layer**: Bootstraps the application, configures DI container, and starts the server
+const service = new Service({
+  architecture: {
+    server: {
+      databases: [
+        {
+          vendor: "MONGOOSE",
+          instance: mongoose,
+          connectionString: "mongodb://localhost/mydb",
+        },
+      ],
+    },
+  },
+});
+```
 
----
+### Custom Repository Pattern
 
-## 3. Core Architectural Concepts
+Implement `IRepository<T>` for any database:
 
-- **Layered (Hexagonal) Architecture:**
-  - Platform → Application → Domain → Infrastructure
-  - Strict separation of concerns; each layer has a single responsibility.
-- **Error Handling:** All errors extend `CustomError` (see `src/error/`).
-- **Validation:** Use `zod` schemas for all request/response validation.
-- **Service Registration:** Register handlers/services in the DI container.
+```typescript
+import { IRepository } from "@sentzunhat/zacatl";
+
+class MyRepository<T> implements IRepository<T> {
+  findById = async (id: string): Promise<T | null> => {
+    /* ... */
+  };
+  findMany = async (filter: Record<string, unknown>): Promise<T[]> => {
+    /* ... */
+  };
+  create = async (data: T): Promise<T> => {
+    /* ... */
+  };
+  update = async (id: string, data: Partial<T>): Promise<void> => {
+    /* ... */
+  };
+  delete = async (id: string): Promise<void> => {
+    /* ... */
+  };
+  exists = async (id: string): Promise<boolean> => {
+    /* ... */
+  };
+}
+```
 
----
+## 🌐 Internationalization
 
-## 4. Coding Standards for Humans and AI
+```typescript
+import { createI18n, FilesystemAdapter } from "@sentzunhat/zacatl";
 
-- **Naming:**
-  - Files/folders: lowercase, hyphens (e.g., `user-repository.ts`)
-  - Classes: PascalCase
-  - Functions/variables: camelCase, descriptive
-- **Code Style:**
-  - Clean, modular, and straightforward
-  - Use strong typing and TypeScript generics
-  - DRY principle: extract reusable logic
-  - Minimal comments; use tests to document behavior
-  - Validate all inputs and sanitize external data
-- **AI Patterns:**
-  - Replicate DI, modularity, and test structure
-  - Update YAML docs when generating new code
+const i18n = createI18n();
+const greeting = i18n.t("greeting"); // Loads from src/localization/locales/
 
----
+await i18n.setLanguage("es");
+const saludo = i18n.t("greeting"); // Translations loaded automatically
+```
 
-## 5. Dependency Injection (DI) Details
+Place translation files in `src/localization/locales/`:
 
-- **DI Container:** All services, repositories, and handlers are registered using `tsyringe`.
-- **No direct instantiation:** Always resolve dependencies via DI.
-- **AI Registration:** When generating new components, ensure they are registered in the DI container.
+```json
+// en.json
+{ "greeting": "Hello {{name}}", "errors": { "notFound": "Not found" } }
+```
 
----
+```json
+// es.json
+{ "greeting": "Hola {{name}}", "errors": { "notFound": "No encontrado" } }
+```
 
-## 6. Database Schema & Persistence
+## ✅ Validation with Zod
 
-- **MongoDB schemas:** Define all schemas in `src/micro-service/architecture/infrastructure/repositories/`.
-- **Repository pattern:** Extend `BaseRepository` for new collections.
-- **Schema best practices:**
-  - Favor embedding for related data
-  - Keep schemas minimal and property names concise
-  - Use references for large or independent data
-  - See `mongodb.yaml` for full guidelines
+```typescript
+import { z } from "zod";
+import { loadConfig } from "@sentzunhat/zacatl";
+
+const AppConfigSchema = z.object({
+  server: z.object({
+    port: z.number().min(1).max(65535),
+    host: z.string(),
+  }),
+  logLevel: z.enum(["debug", "info", "warn", "error"]).default("info"),
+});
 
----
+const config = loadConfig("./config/app.yaml", "yaml", AppConfigSchema);
+```
 
-## 7. Error Management and Validation
+## 🛡️ Error Handling
 
-- **Error Classes:** All errors extend `CustomError` (see `src/error/`).
-- **Throw, don’t return:** Always throw errors for exceptional cases.
-- **Validation:** Use `zod` for all request/response validation. Place schemas in the Application layer.
+Zacatl includes 7 custom error types with built-in correlation IDs:
 
----
+```typescript
+import {
+  BadRequestError,
+  NotFoundError,
+  UnauthorizedError,
+  ForbiddenError,
+  ValidationError,
+  InternalServerError,
+  BadResourceError,
+} from "@sentzunhat/zacatl";
+
+throw new ValidationError("Email is required");
+throw new NotFoundError("User not found", { userId: 123 });
+```
 
-## 8. Testing Philosophy and Setup
+## 🧪 Testing
 
-- **Framework:** Use `vitest` for all tests.
-- **Structure:** Place tests in `test/unit/`, mirroring the `src/` structure.
-- **Mocking:** Mock all external dependencies (DB, services) in tests.
-- **AI Testing:** When generating new logic, always add or update tests.
+Zacatl comes with **161 passing tests** and **79% coverage**:
 
----
+```bash
+npm test                 # Run all tests
+npm run test:watch      # Watch mode
+npm run test:coverage   # Coverage report
+```
 
-## 9. Minimal Usage Example
+Example test with mocking:
 
 ```typescript
-import Fastify from "fastify";
-import { MicroService } from "@sentzunhat/zacatl";
+import { describe, it, expect, vi } from "vitest";
 
-const fastifyApp = Fastify();
+describe("UserService", () => {
+  it("should create a user", async () => {
+    const mockRepo = { create: vi.fn().mockResolvedValue({ id: "1" }) };
+    const service = new UserService(mockRepo as any);
 
-const microservice = new MicroService({
-  architecture: {
-    application: {
-      entryPoints: {
-        rest: {
-          hookHandlers: [], // Add hook handler classes
-          routeHandlers: [], // Add route handler classes
-        },
-      },
-    },
-    domain: { providers: [] }, // Add domain provider classes
-    infrastructure: { repositories: [] }, // Add repository classes
-    service: {
-      name: "my-service",
-      server: {
-        type: "SERVER",
-        vendor: "FASTIFY",
-        instance: fastifyApp,
-      },
-      databases: [
-        // Example for MongoDB:
-        // {
-        //   vendor: "MONGOOSE",
-        //   instance: new Mongoose(),
-        //   connectionString: "mongodb://localhost/mydb",
-        // }
-      ],
-    },
-  },
+    const result = await service.createUser({ name: "John" });
+
+    expect(result.id).toBe("1");
+    expect(mockRepo.create).toHaveBeenCalledOnce();
+  });
 });
+```
+
+## 🔍 Runtime Detection
+
+Check which runtime you're using:
 
-await microservice.start({ port: 9000 });
+```typescript
+import {
+  detectRuntime,
+  isBun,
+  isNode,
+  getRuntimeType,
+  getRuntimeVersion,
+} from "@sentzunhat/zacatl";
+
+const runtime = detectRuntime();
+console.log(runtime.type); // "node" | "bun" | "unknown"
+console.log(runtime.version); // "22.11.0"
+
+if (isNode()) {
+  // Node.js specific code
+}
+```
+
+## 📦 What's Included
+
+```
+src/
+├── service/architecture/       # Core framework
+│   ├── application/            # HTTP handlers, validation
+│   ├── domain/                 # Business logic
+│   ├── infrastructure/         # Repositories, adapters
+│   └── platform/               # DI setup, server startup
+├── configuration/              # Config loading & validation
+├── error/                      # 7 custom error types
+├── localization/               # i18n with adapters
+├── logs/                       # Pino logging
+└── utils/                      # Runtime detection, base64, HMAC
 ```
 
----
+## 🛠️ Development
 
-## 10. Configuration and Environment Variables
+### Building
 
-- **Localization:** Place locale JSON files in `src/locales/` (e.g., `en.json`)
-- **Environment Variables:**
-  - `SERVICE_NAME` - Service name
-  - `NODE_ENV` - Environment (development, production, test)
-  - `CONNECTION_STRING` - Database connection string
+```bash
+npm run build      # Compile TypeScript to build/
+npm run build:watch # Watch mode
+```
 
----
+### Code Quality
 
-## 11. Extending the Codebase (for Humans & AI)
+```bash
+npm run lint       # Run ESLint
+npm run type:check # TypeScript checking
+```
 
-- Add new features by creating new handlers, services, or repositories in the appropriate layer.
-- Register all new classes in the DI container.
-- Write tests for all new logic.
-- Update YAML docs (`context.yaml`, `guidelines.yaml`, `patterns.yaml`, `mongodb.yaml`) with new patterns or conventions.
+## 📋 Requirements
 
----
+- **Node.js**: 24.0.0 or higher (LTS)
+- **npm**: 10.0.0 or higher (bundled with Node 24)
+- **TypeScript**: 5.9+ (we use 5.9.3)
 
-## 12. Documentation References
+Optional:
 
-- [`context.yaml`](./context.yaml): Architecture, components, and project context
-- [`guidelines.yaml`](./guidelines.yaml): Coding standards and best practices
-- [`patterns.yaml`](./patterns.yaml): Design and usage patterns
-- [`mongodb.yaml`](./mongodb.yaml): MongoDB schema guidelines
+- **Bun**: Latest for fast package management (development only)
 
----
+## 📄 License
 
-## 13. Contributing Workflow
+[MIT License](./LICENSE) © 2025 Sentzunhat
 
-### For Humans
+## 🤝 Contributing
 
 1. Fork the repository
-2. Create your feature branch: `git checkout -b feature/amazing-feature`
-3. Commit your changes: `git commit -m 'Add some amazing feature'`
-4. Push to the branch: `git push origin feature/amazing-feature`
-5. Open a Pull Request
-6. Ensure all tests pass and docs are updated
+2. Create a feature branch: `git checkout -b feature/amazing-feature`
+3. Add tests for your changes
+4. Update documentation
+5. Commit: `git commit -m 'Add amazing feature'`
+6. Push: `git push origin feature/amazing-feature`
+7. Open a Pull Request
 
-### For AI Agents
+## 📞 Support
 
-- Parse YAML docs for context and conventions
-- Register new code in the DI container
-- Add or update tests in `test/unit/`
-- Update YAML docs with new features or patterns
+- 📖 [Documentation](./docs/INDEX.md)
+- 🐛 [Issue Tracker](https://github.com/sentzunhat/zacatl/issues)
+- 💬 [Discussions](https://github.com/sentzunhat/zacatl/discussions)
 
----
+## 🙋 About
 
-## 14. License and Maintainers
+Zacatl is built for developers who value clean architecture, type safety, and test-driven development. It's equally useful for humans and AI agents building production services.
 
-- **License:** MIT License © 2025 Sentzunhat
-- **Maintainer:** Diego Beltran ([LinkedIn](https://www.linkedin.com/in/diego-beltran))
-- **Project URL:** [GitHub](https://github.com/sentzunhat/zacatl)
+**Created by**: [Diego Beltran](https://www.linkedin.com/in/diego-beltran)  
+**Repository**: https://github.com/sentzunhat/zacatl  
+**npm**: https://www.npmjs.com/package/@sentzunhat/zacatl
 
----
+## 🤖 Acknowledgments
 
-_For all details, see the YAML documentation files above. Zacatl is designed for seamless collaboration between humans and AI agents._
+This framework was built with assistance from **GitHub Copilot** and friendly ML/LLM models, demonstrating effective human-AI collaboration in software development.

package/build/architecture/index.d.ts

@@ -0,0 +1,2 @@
+export * from "../service/architecture";
+//# sourceMappingURL=index.d.ts.map

package/build/architecture/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"./src/","sources":["architecture/index.ts"],"names":[],"mappings":"AAMA,cAAc,yBAAyB,CAAC"}

package/build/architecture/index.js

@@ -0,0 +1,2 @@
+export * from "../service/architecture";
+//# sourceMappingURL=index.js.map

package/build/architecture/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"./src/","sources":["architecture/index.ts"],"names":[],"mappings":"AAMA,cAAc,yBAAyB,CAAC","sourcesContent":["/**\n * Core Architecture Module\n *\n * This entry point exposes the hexagonal architecture components (Application, Domain, Infrastructure).\n * Provides a cleaner import path for service architecture.\n */\nexport * from \"../service/architecture\";\n"]}

package/build/configuration/app-config.d.ts

@@ -0,0 +1,10 @@
+type ConfigInput = {
+    SERVICE_NAME: string;
+    NODE_ENV: string;
+    APP_VERSION: string;
+    APP_ENV: string;
+    CONNECTION_STRING: string;
+};
+export declare const getConfigOrThrow: <T>(name: keyof ConfigInput) => T;
+export {};
+//# sourceMappingURL=app-config.d.ts.map

package/build/configuration/app-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-config.d.ts","sourceRoot":"./src/","sources":["configuration/app-config.ts"],"names":[],"mappings":"AAOA,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAQF,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,MAAM,MAAM,WAAW,KAAG,CAE7D,CAAC"}

package/build/configuration/app-config.js

@@ -0,0 +1,5 @@
+import config from "config";
+export const getConfigOrThrow = (name) => {
+    return config.get(name);
+};
+//# sourceMappingURL=app-config.js.map

package/build/configuration/app-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-config.js","sourceRoot":"./src/","sources":["configuration/app-config.ts"],"names":[],"mappings":"AAKA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAgB5B,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAI,IAAuB,EAAK,EAAE;IAChE,OAAO,MAAM,CAAC,GAAG,CAAI,IAAI,CAAC,CAAC;AAC7B,CAAC,CAAC","sourcesContent":["/**\n * Application-wide configuration via node-config\n * Loads from config/ directory with environment-specific overrides\n */\n\nimport config from \"config\";\n\ntype ConfigInput = {\n  SERVICE_NAME: string;\n  NODE_ENV: string;\n  APP_VERSION: string;\n  APP_ENV: string;\n  CONNECTION_STRING: string;\n};\n\n/**\n * Get application configuration value from node-config\n * Reads from config/default.{json,yaml} + config/{NODE_ENV}.{json,yaml}\n * @param name - Configuration key\n * @returns Configuration value\n */\nexport const getConfigOrThrow = <T>(name: keyof ConfigInput): T => {\n  return config.get<T>(name);\n};\n"]}

package/build/configuration/index.d.ts

@@ -0,0 +1,7 @@
+export type { ConfigFormat, ConfigLoader, LoadedConfig } from "./types";
+export { JSONLoader, createJSONLoader } from "./loaders/json-loader";
+export { YAMLLoader, createYAMLLoader } from "./loaders/yaml-loader";
+export { getLoader, loadConfig, loadConfigFromPaths } from "./loader";
+export { validateConfig, validateLoadedConfig, safeValidateConfig, } from "./validation";
+export { getConfigOrThrow } from "./app-config";
+//# sourceMappingURL=index.d.ts.map

package/build/configuration/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"./src/","sources":["configuration/index.ts"],"names":[],"mappings":"AAKA,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAExE,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAErE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEtE,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

package/build/configuration/index.js

@@ -0,0 +1,6 @@
+export { JSONLoader, createJSONLoader } from "./loaders/json-loader";
+export { YAMLLoader, createYAMLLoader } from "./loaders/yaml-loader";
+export { getLoader, loadConfig, loadConfigFromPaths } from "./loader";
+export { validateConfig, validateLoadedConfig, safeValidateConfig, } from "./validation";
+export { getConfigOrThrow } from "./app-config";
+//# sourceMappingURL=index.js.map