promidas 2.0.0

package/dist/index.js

@@ -0,0 +1,70 @@
+/**
+ * Public entrypoint for the promidas library.
+ *
+ * ## Quick Start
+ *
+ * For most use cases, use the Builder to create a Repository:
+ *
+ * @example
+ * ```typescript
+ * import { PromidasRepositoryBuilder } from 'promidas';
+ *
+ * const repo = new PromidasRepositoryBuilder()
+ *   .setStoreConfig({ ttlMs: 30 * 60 * 1000 })
+ *   .setApiClientConfig({
+ *     protoPediaApiClientOptions: { token: process.env.PROTOPEDIA_API_V2_TOKEN }
+ *   })
+ *   .build();
+ *
+ * await repo.setupSnapshot({ limit: 100 });
+ * const prototype = await repo.getRandomPrototypeFromSnapshot();
+ * ```
+ *
+ * ## Standalone Module Usage
+ *
+ * For advanced use cases or when you need specific modules independently,
+ * use subpath imports:
+ *
+ * @example
+ * ```typescript
+ * // Type definitions
+ * import type { NormalizedPrototype } from 'promidas/types';
+ *
+ * // Utility functions and converters
+ * import {
+ *   parseProtoPediaTimestamp,
+ *   getPrototypeStatusLabel
+ * } from 'promidas/utils';
+ *
+ * // Logger interface and implementations
+ * import { createConsoleLogger } from 'promidas/logger';
+ *
+ * // API client and data fetching
+ * import {
+ *   ProtopediaApiCustomClient
+ * } from 'promidas/fetcher';
+ *
+ * // In-memory store
+ * import { PrototypeInMemoryStore } from 'promidas/store';
+ *
+ * // Repository builder
+ * import { PromidasRepositoryBuilder } from 'promidas';
+ * ```
+ *
+ * ## Available Subpath Exports
+ *
+ * - `promidas/types` — Type definitions (NormalizedPrototype)
+ * - `promidas/utils` — Utility functions and converters
+ * - `promidas/logger` — Logger interface and implementations
+ * - `promidas/fetcher` — API client and data fetching utilities
+ * - `promidas/store` — In-memory store implementation
+ *
+ * @packageDocumentation
+ */
+// Builder for creating repository instances
+export { 
+// Builder for advanced use cases
+PromidasRepositoryBuilder, } from './builder.js';
+// Factory functions for common use cases
+export { createPromidasForLocal, createPromidasForServer } from './factory.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH,4CAA4C;AAC5C,OAAO;AACL,iCAAiC;AACjC,yBAAyB,GAgB1B,MAAM,cAAc,CAAC;AAEtB,yCAAyC;AACzC,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC"}

package/dist/logger/console-logger.d.ts

@@ -0,0 +1,74 @@
+import type { Logger, LogLevel } from './logger.types.js';
+/**
+ * Universal console-based logger.
+ *
+ * Works in Browser, Node.js, and Edge environments.
+ * Safe for environments without `console` (silently skips logging).
+ *
+ * @remarks
+ * - Implements the Logger interface with mutable `level` property
+ * - Uses native console methods (console.error, console.warn, etc.)
+ * - Respects the current log level for filtering output
+ * - Level can be changed at runtime via the `level` property
+ *
+ * @example
+ * ```typescript
+ * // Create with specific level
+ * const debugLogger = new ConsoleLogger('debug');
+ * debugLogger.debug('Detailed info'); // Will be logged
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Default level ('info')
+ * const logger = new ConsoleLogger();
+ * logger.debug('Not logged'); // debug < info
+ * logger.info('Logged'); // info = info
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Change level dynamically
+ * const logger = new ConsoleLogger('error');
+ * logger.info('Not logged'); // info < error
+ * logger.level = 'info';
+ * logger.info('Now logged'); // info = info
+ * ```
+ */
+export declare class ConsoleLogger implements Logger {
+    level: LogLevel;
+    private readonly hasConsole;
+    /**
+     * Creates a new ConsoleLogger instance.
+     *
+     * @param level - Initial log level (default: 'info')
+     *
+     * @example
+     * ```typescript
+     * // Default level
+     * const logger = new ConsoleLogger(); // 'info'
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Specific level
+     * const debugLogger = new ConsoleLogger('debug');
+     * const errorLogger = new ConsoleLogger('error');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Level can be changed after creation
+     * const logger = new ConsoleLogger('info');
+     * logger.level = 'debug'; // Now shows debug logs
+     * ```
+     */
+    constructor(level?: LogLevel);
+    error(message: string, meta?: unknown): void;
+    warn(message: string, meta?: unknown): void;
+    info(message: string, meta?: unknown): void;
+    debug(message: string, meta?: unknown): void;
+    private log;
+    private shouldLog;
+}
+//# sourceMappingURL=console-logger.d.ts.map

package/dist/logger/console-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-logger.d.ts","sourceRoot":"","sources":["../../lib/logger/console-logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAa1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,aAAc,YAAW,MAAM;IAC1C,KAAK,EAAE,QAAQ,CAAC;IAEhB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAU;IAErC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;gBACS,KAAK,GAAE,QAAiB;IAYpC,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAI5C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAI3C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAI3C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAI5C,OAAO,CAAC,GAAG;IAoBX,OAAO,CAAC,SAAS;CAIlB"}

package/dist/logger/console-logger.js

@@ -0,0 +1,113 @@
+const LEVEL_ORDER = ['debug', 'info', 'warn', 'error', 'silent'];
+const getConsoleFn = (method) => {
+    const hasConsole = typeof console !== 'undefined';
+    return hasConsole && typeof console[method] === 'function'
+        ? console[method].bind(console)
+        : undefined;
+};
+/**
+ * Universal console-based logger.
+ *
+ * Works in Browser, Node.js, and Edge environments.
+ * Safe for environments without `console` (silently skips logging).
+ *
+ * @remarks
+ * - Implements the Logger interface with mutable `level` property
+ * - Uses native console methods (console.error, console.warn, etc.)
+ * - Respects the current log level for filtering output
+ * - Level can be changed at runtime via the `level` property
+ *
+ * @example
+ * ```typescript
+ * // Create with specific level
+ * const debugLogger = new ConsoleLogger('debug');
+ * debugLogger.debug('Detailed info'); // Will be logged
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Default level ('info')
+ * const logger = new ConsoleLogger();
+ * logger.debug('Not logged'); // debug < info
+ * logger.info('Logged'); // info = info
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Change level dynamically
+ * const logger = new ConsoleLogger('error');
+ * logger.info('Not logged'); // info < error
+ * logger.level = 'info';
+ * logger.info('Now logged'); // info = info
+ * ```
+ */
+export class ConsoleLogger {
+    level;
+    hasConsole;
+    /**
+     * Creates a new ConsoleLogger instance.
+     *
+     * @param level - Initial log level (default: 'info')
+     *
+     * @example
+     * ```typescript
+     * // Default level
+     * const logger = new ConsoleLogger(); // 'info'
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Specific level
+     * const debugLogger = new ConsoleLogger('debug');
+     * const errorLogger = new ConsoleLogger('error');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Level can be changed after creation
+     * const logger = new ConsoleLogger('info');
+     * logger.level = 'debug'; // Now shows debug logs
+     * ```
+     */
+    constructor(level = 'info') {
+        this.level = level;
+        this.hasConsole = typeof console !== 'undefined';
+        // Bind methods to preserve `this` when methods are passed around as callbacks.
+        // Some upstream libraries call logger methods without a receiver.
+        this.error = this.error.bind(this);
+        this.warn = this.warn.bind(this);
+        this.info = this.info.bind(this);
+        this.debug = this.debug.bind(this);
+    }
+    error(message, meta) {
+        this.log('error', message, meta, getConsoleFn('error'));
+    }
+    warn(message, meta) {
+        this.log('warn', message, meta, getConsoleFn('warn'));
+    }
+    info(message, meta) {
+        this.log('info', message, meta, getConsoleFn('info'));
+    }
+    debug(message, meta) {
+        this.log('debug', message, meta, getConsoleFn('debug'));
+    }
+    log(targetLevel, message, meta, consoleFn) {
+        if (!this.shouldLog(targetLevel) || !this.hasConsole || !consoleFn) {
+            return;
+        }
+        const prefix = `[${targetLevel.toUpperCase()}]`;
+        const formattedMessage = `${prefix} ${message}`;
+        if (meta === undefined) {
+            consoleFn(formattedMessage);
+        }
+        else {
+            consoleFn(formattedMessage, meta);
+        }
+    }
+    shouldLog(target) {
+        if (this.level === 'silent')
+            return false;
+        return LEVEL_ORDER.indexOf(target) >= LEVEL_ORDER.indexOf(this.level);
+    }
+}
+//# sourceMappingURL=console-logger.js.map

package/dist/logger/console-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-logger.js","sourceRoot":"","sources":["../../lib/logger/console-logger.ts"],"names":[],"mappings":"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"}

package/dist/logger/factory.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Logger factory functions.
+ *
+ * This module provides factory functions for creating logger instances:
+ * - {@link createConsoleLogger} — Creates a console-based logger with default 'info' level
+ * - {@link createNoopLogger} — Creates a no-op logger for testing/production
+ *
+ * @module
+ */
+import { ConsoleLogger } from './console-logger.js';
+import type { Logger } from './logger.types.js';
+/**
+ * Create a console-based logger with default 'info' level.
+ *
+ * @returns ConsoleLogger instance with 'info' level
+ *
+ * @remarks
+ * **When to use each approach:**
+ * 1. `createConsoleLogger()` - Best for most cases, especially with Repository/Store
+ * 2. `new ConsoleLogger(level)` - When you need a specific level at creation
+ * 3. `logger.level = level` - When you need to change level dynamically
+ *
+ * @example
+ * ```typescript
+ * // Recommended: Use with Repository/Store
+ * const logger = createConsoleLogger();
+ * const repo = new PromidasRepositoryBuilder()
+ *   .setStoreConfig({ logger, logLevel: 'debug' })
+ *   .setApiClientConfig({
+ *     logger,
+ *     logLevel: 'debug',
+ *     protoPediaApiClientOptions: { token: process.env.PROTOPEDIA_API_V2_TOKEN }
+ *   })
+ *   .build();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Default level ('info')
+ * const logger = createConsoleLogger();
+ * logger.info('Application started'); // Logged
+ * logger.debug('Debug info'); // Not logged (debug < info)
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Change level dynamically
+ * const logger = createConsoleLogger();
+ * logger.level = 'debug';
+ * logger.debug('Now this is logged');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // If you need a specific level at creation time:
+ * const logger = new ConsoleLogger('debug');
+ * ```
+ */
+export declare const createConsoleLogger: () => ConsoleLogger;
+/**
+ * Create a no-op logger (for testing or silent mode).
+ *
+ * All logging methods do nothing and return immediately.
+ * This is useful for:
+ * - Unit tests (suppress log output)
+ * - Production environments (completely disable logging)
+ * - Performance-critical code (zero logging overhead)
+ *
+ * @returns Logger that does nothing
+ *
+ * @example
+ * ```typescript
+ * // Use in tests
+ * const logger = createNoopLogger();
+ * logger.error('This will not be logged');
+ * logger.info('Neither will this');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Conditional logger selection
+ * const logger = process.env.ENABLE_LOGGING === 'true'
+ *   ? createConsoleLogger()
+ *   : createNoopLogger();
+ * ```
+ */
+export declare const createNoopLogger: () => Logger;
+//# sourceMappingURL=factory.d.ts.map

package/dist/logger/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../lib/logger/factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,mBAAmB,QAAO,aAEtC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,gBAAgB,QAAO,MAKlC,CAAC"}

package/dist/logger/factory.js

@@ -0,0 +1,94 @@
+/**
+ * Logger factory functions.
+ *
+ * This module provides factory functions for creating logger instances:
+ * - {@link createConsoleLogger} — Creates a console-based logger with default 'info' level
+ * - {@link createNoopLogger} — Creates a no-op logger for testing/production
+ *
+ * @module
+ */
+import { ConsoleLogger } from './console-logger.js';
+/**
+ * Create a console-based logger with default 'info' level.
+ *
+ * @returns ConsoleLogger instance with 'info' level
+ *
+ * @remarks
+ * **When to use each approach:**
+ * 1. `createConsoleLogger()` - Best for most cases, especially with Repository/Store
+ * 2. `new ConsoleLogger(level)` - When you need a specific level at creation
+ * 3. `logger.level = level` - When you need to change level dynamically
+ *
+ * @example
+ * ```typescript
+ * // Recommended: Use with Repository/Store
+ * const logger = createConsoleLogger();
+ * const repo = new PromidasRepositoryBuilder()
+ *   .setStoreConfig({ logger, logLevel: 'debug' })
+ *   .setApiClientConfig({
+ *     logger,
+ *     logLevel: 'debug',
+ *     protoPediaApiClientOptions: { token: process.env.PROTOPEDIA_API_V2_TOKEN }
+ *   })
+ *   .build();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Default level ('info')
+ * const logger = createConsoleLogger();
+ * logger.info('Application started'); // Logged
+ * logger.debug('Debug info'); // Not logged (debug < info)
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Change level dynamically
+ * const logger = createConsoleLogger();
+ * logger.level = 'debug';
+ * logger.debug('Now this is logged');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // If you need a specific level at creation time:
+ * const logger = new ConsoleLogger('debug');
+ * ```
+ */
+export const createConsoleLogger = () => {
+    return new ConsoleLogger('info');
+};
+/**
+ * Create a no-op logger (for testing or silent mode).
+ *
+ * All logging methods do nothing and return immediately.
+ * This is useful for:
+ * - Unit tests (suppress log output)
+ * - Production environments (completely disable logging)
+ * - Performance-critical code (zero logging overhead)
+ *
+ * @returns Logger that does nothing
+ *
+ * @example
+ * ```typescript
+ * // Use in tests
+ * const logger = createNoopLogger();
+ * logger.error('This will not be logged');
+ * logger.info('Neither will this');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Conditional logger selection
+ * const logger = process.env.ENABLE_LOGGING === 'true'
+ *   ? createConsoleLogger()
+ *   : createNoopLogger();
+ * ```
+ */
+export const createNoopLogger = () => ({
+    error: () => { },
+    warn: () => { },
+    info: () => { },
+    debug: () => { },
+});
+//# sourceMappingURL=factory.js.map

package/dist/logger/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../lib/logger/factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAkB,EAAE;IACrD,OAAO,IAAI,aAAa,CAAC,MAAM,CAAC,CAAC;AACnC,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAW,EAAE,CAAC,CAAC;IAC7C,KAAK,EAAE,GAAG,EAAE,GAAE,CAAC;IACf,IAAI,EAAE,GAAG,EAAE,GAAE,CAAC;IACd,IAAI,EAAE,GAAG,EAAE,GAAE,CAAC;IACd,KAAK,EAAE,GAAG,EAAE,GAAE,CAAC;CAChB,CAAC,CAAC"}

package/dist/logger/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Logger module for Promidas.
+ *
+ * This module provides logging utilities and types:
+ * - {@link Logger} — Logger interface for custom logging implementations.
+ * - {@link LogLevel} — Log level type for controlling verbosity.
+ * - {@link ConsoleLogger} — Console-based logger class with mutable level.
+ * - {@link createConsoleLogger} — Factory to create a console logger with default 'info' level.
+ * - {@link createNoopLogger} — Factory to create a no-op logger.
+ *
+ * @example
+ * ```typescript
+ * // Using the factory (default 'info' level)
+ * const logger = createConsoleLogger();
+ * logger.info('Application started');
+ * logger.level = 'debug'; // Change level dynamically
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using the constructor for specific level
+ * const debugLogger = new ConsoleLogger('debug');
+ * debugLogger.debug('Detailed debug info');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With Repository/Store (recommended pattern)
+ * import { PromidasRepositoryBuilder } from 'promidas';
+ * const logger = createConsoleLogger();
+ * const repo = new PromidasRepositoryBuilder()
+ *   .setStoreConfig({ logger, logLevel: 'debug' })
+ *   .setRepositoryConfig({ logger })
+ *   .build();
+ * ```
+ *
+ * @module
+ */
+export type { Logger, LogLevel } from './logger.types.js';
+export { ConsoleLogger } from './console-logger.js';
+export { createConsoleLogger, createNoopLogger } from './factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/logger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/logger/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

package/dist/logger/index.js

@@ -0,0 +1,41 @@
+/**
+ * Logger module for Promidas.
+ *
+ * This module provides logging utilities and types:
+ * - {@link Logger} — Logger interface for custom logging implementations.
+ * - {@link LogLevel} — Log level type for controlling verbosity.
+ * - {@link ConsoleLogger} — Console-based logger class with mutable level.
+ * - {@link createConsoleLogger} — Factory to create a console logger with default 'info' level.
+ * - {@link createNoopLogger} — Factory to create a no-op logger.
+ *
+ * @example
+ * ```typescript
+ * // Using the factory (default 'info' level)
+ * const logger = createConsoleLogger();
+ * logger.info('Application started');
+ * logger.level = 'debug'; // Change level dynamically
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using the constructor for specific level
+ * const debugLogger = new ConsoleLogger('debug');
+ * debugLogger.debug('Detailed debug info');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With Repository/Store (recommended pattern)
+ * import { PromidasRepositoryBuilder } from 'promidas';
+ * const logger = createConsoleLogger();
+ * const repo = new PromidasRepositoryBuilder()
+ *   .setStoreConfig({ logger, logLevel: 'debug' })
+ *   .setRepositoryConfig({ logger })
+ *   .build();
+ * ```
+ *
+ * @module
+ */
+export { ConsoleLogger } from './console-logger.js';
+export { createConsoleLogger, createNoopLogger } from './factory.js';
+//# sourceMappingURL=index.js.map

package/dist/logger/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/logger/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

package/dist/logger/logger.types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Log levels supported by PROMIDAS loggers.
+ *
+ * @remarks
+ * Levels are ordered from most verbose to least verbose:
+ * - debug: Detailed information for debugging
+ * - info: General informational messages
+ * - warn: Warning messages
+ * - error: Error messages
+ * - silent: No logging output
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+/**
+ * Logger interface for PROMIDAS.
+ *
+ * This interface is compatible with protopedia-api-v2-client Logger.
+ * Follows the Fastify/NestJS pattern where log level is managed separately.
+ *
+ * @remarks
+ * - Universal: works in Browser, Node.js, and Edge environments
+ * - Level is managed externally (not part of the interface)
+ * - Default implementation uses `console` (universal)
+ * - Compatible with protopedia-api-v2-client Logger instances
+ *
+ * @example
+ * ```typescript
+ * const logger = createConsoleLogger();
+ * logger.debug('Debug message', { userId: 123 });
+ * ```
+ */
+export interface Logger {
+    /**
+     * Log error messages (highest priority).
+     */
+    error: (message: string, meta?: unknown) => void;
+    /**
+     * Log warning messages.
+     */
+    warn: (message: string, meta?: unknown) => void;
+    /**
+     * Log informational messages.
+     */
+    info: (message: string, meta?: unknown) => void;
+    /**
+     * Log debug messages (lowest priority).
+     */
+    debug: (message: string, meta?: unknown) => void;
+}
+//# sourceMappingURL=logger.types.d.ts.map

package/dist/logger/logger.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.types.d.ts","sourceRoot":"","sources":["../../lib/logger/logger.types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEtE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,MAAM;IACrB;;OAEG;IACH,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAEjD;;OAEG;IACH,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAEhD;;OAEG;IACH,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAEhD;;OAEG;IACH,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;CAClD"}

package/dist/logger/logger.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logger.types.js.map

package/dist/logger/logger.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.types.js","sourceRoot":"","sources":["../../lib/logger/logger.types.ts"],"names":[],"mappings":""}

package/dist/repository/errors/validation-error.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Validation error thrown when invalid arguments are provided to repository methods.
+ *
+ * This error wraps Zod validation errors to hide the Zod dependency from users.
+ *
+ * @public
+ */
+export declare class ValidationError extends Error {
+    /**
+     * The name of the field that failed validation.
+     */
+    readonly field: string;
+    /**
+     * Creates a new ValidationError.
+     *
+     * @param message - Human-readable error message
+     * @param field - The name of the field that failed validation
+     * @param options - Error options, including the original error cause for debugging
+     */
+    constructor(message: string, field: string, options?: {
+        cause?: Error;
+    });
+}
+//# sourceMappingURL=validation-error.d.ts.map

package/dist/repository/errors/validation-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-error.d.ts","sourceRoot":"","sources":["../../../lib/repository/errors/validation-error.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC;;OAEG;IACH,SAAgB,KAAK,EAAE,MAAM,CAAC;IAE9B;;;;;;OAMG;gBAED,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,KAAK,CAAC;KACf;CAMJ"}

package/dist/repository/errors/validation-error.js

@@ -0,0 +1,26 @@
+/**
+ * Validation error thrown when invalid arguments are provided to repository methods.
+ *
+ * This error wraps Zod validation errors to hide the Zod dependency from users.
+ *
+ * @public
+ */
+export class ValidationError extends Error {
+    /**
+     * The name of the field that failed validation.
+     */
+    field;
+    /**
+     * Creates a new ValidationError.
+     *
+     * @param message - Human-readable error message
+     * @param field - The name of the field that failed validation
+     * @param options - Error options, including the original error cause for debugging
+     */
+    constructor(message, field, options) {
+        super(message, options);
+        this.name = 'ValidationError';
+        this.field = field;
+    }
+}
+//# sourceMappingURL=validation-error.js.map

package/dist/repository/errors/validation-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-error.js","sourceRoot":"","sources":["../../../lib/repository/errors/validation-error.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,OAAO,eAAgB,SAAQ,KAAK;IACxC;;OAEG;IACa,KAAK,CAAS;IAE9B;;;;;;OAMG;IACH,YACE,OAAe,EACf,KAAa,EACb,OAEC;QAED,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;CACF"}