@mrxsys/mrx-core 2.8.0 → 2.9.0-1-and-259-20250918

package/dist/modules/logger/logger.d.ts

@@ -1,189 +1,189 @@
-import { TypedEventEmitter } from '../../modules/typedEventEmitter/typedEventEmitter';
-import type { LoggerEvent } from './events/loggerEvents';
-import type { BodiesIntersection } from './types/bodiesIntersection';
-import type { LoggerStrategy } from './types/loggerStrategy';
-import type { StrategyMap } from './types/strategyMap';
+import { TypedEventEmitter } from '../../modules/typed-event-emitter/typed-event-emitter';
+import type { LoggerEvent } from './events/logger-events';
+import type { BodiesIntersection } from './types/bodies-intersection';
+import type { LoggerSink } from './types/logger-sink';
+import type { SinkMap } from './types/sink-map';
 /**
-* Logger provides a flexible, type-safe logging system that allows multiple strategies for log output.
-* The logger uses a transform stream to process log entries and execute the logging strategies.
-*
-* Logger extends the TypedEventEmitter class to emit typed events when an error occurs or when the logger ends.
-* The logger can log messages with different levels: error, warn, info, debug, and log.
-*
-* @template TStrategies - The map of strategy names to LoggerStrategy types.
-*/
-export declare class Logger<TStrategies extends StrategyMap = {}> extends TypedEventEmitter<LoggerEvent> {
-    /**
-    * The map of strategies.
-    */
-    private readonly _strategies;
-    /**
-    * The transform stream for processing log entries.
-    */
+ * Logger provides a flexible, type-safe logging system that allows multiple sinks for log output.
+ * The logger uses a transform stream to process log entries and execute the logging sinks.
+ *
+ * Logger extends the TypedEventEmitter class to emit typed events when an error occurs or when the logger ends.
+ * The logger can log messages with different levels: error, warn, info, debug, and log.
+ *
+ * @template TSinks - The map of sink names to LoggerStrategy types.
+ */
+export declare class Logger<TSinks extends SinkMap = {}> extends TypedEventEmitter<LoggerEvent> {
+    /**
+     * The map of sinks.
+     */
+    private readonly _sinks;
+    /**
+     * The transform stream for processing log entries.
+     */
     private readonly _logStream;
     /**
-    * The queue of pending log entries.
-    */
+     * The queue of pending log entries.
+     */
     private readonly _pendingLogs;
     /**
-    * The maximum number of pending logs.
-    * @defaultValue 10_000
-    */
+     * The maximum number of pending logs.
+     * @defaultValue 10_000
+     */
     private readonly _maxPendingLogs;
     /**
-    * Flag to indicate if the logger is currently writing logs.
-    */
+     * Flag to indicate if the logger is currently writing logs.
+     */
     private _isWriting;
     /**
-    * Construct a Logger.
-    *
-    * @template TStrategies - The map of strategy names to LoggerStrategy types.
-    *
-    * @param strategies - Initial strategies map.
-    *
-    * @param maxPendingLogs - Maximum number of logs in the queue (default: 10_000)
-    */
-    constructor(strategies?: TStrategies, maxPendingLogs?: number);
-    /**
-    * Register a new logging strategy.
-    *
-    * @template Key - The name of the strategy.
-    * @template Strategy - The strategy type.
-    *
-    * @param name - The name of the strategy.
-    * @param strategy - The strategy to add. It must implement {@link LoggerStrategy}.
-    *
-    * @throws ({@link BaseError}) - If the strategy is already added.
-    *
-    * @returns A new Logger instance with the added strategy.
-    */
-    registerStrategy<Key extends string, Strategy extends LoggerStrategy>(name: Key, strategy: Strategy): Logger<TStrategies & Record<Key, Strategy>>;
-    /**
-    * Unregister a logging strategy.
-    *
-    * @template Key - The name of the strategy.
-    *
-    * @param name - The name of the strategy to remove.
-    *
-    * @throws ({@link BaseError}) - If the strategy is not found.
-    *
-    * @returns A new Logger instance without the removed strategy.
-    */
-    unregisterStrategy<Key extends keyof TStrategies>(name: Key): Logger<Omit<TStrategies, Key>>;
-    /**
-    * Register multiple strategies at once.
-    *
-    * @template TNew - The new strategies to add.
-    *
-    * @param strategies - An array of tuples where each tuple contains the strategy name and the strategy instance.
-    *
-    * @throws ({@link BaseError}) - If any strategy is already added.
-    *
-    * @returns A new Logger instance with the added strategies.
-    */
-    registerStrategies<TNew extends [string, LoggerStrategy][] = [string, LoggerStrategy][]>(strategies: TNew): Logger<TStrategies & {
-        [K in TNew[number][0]]: Extract<TNew[number], [K, LoggerStrategy]>[1];
+     * Construct a Logger.
+     *
+     * @template TStrategies - The map of sink names to LoggerStrategy types.
+     *
+     * @param sinks - Initial sinks map.
+     *
+     * @param maxPendingLogs - Maximum number of logs in the queue (default: 10_000)
+     */
+    constructor(sinks?: TSinks, maxPendingLogs?: number);
+    /**
+     * Register a new logging sink.
+     *
+     * @template Key - The name of the sink.
+     * @template Sink - The sink type.
+     *
+     * @param name - The name of the sink.
+     * @param sink - The sink to add. It must implement {@link LoggerSink}.
+     *
+     * @throws ({@link BaseError}) - If the sink is already added.
+     *
+     * @returns A new Logger instance with the added sink.
+     */
+    registerSink<Key extends string, Sink extends LoggerSink>(name: Key, sink: Sink): Logger<TSinks & Record<Key, Sink>>;
+    /**
+     * Unregister a logging sink.
+     *
+     * @template Key - The name of the sink.
+     *
+     * @param name - The name of the sink to remove.
+     *
+     * @throws ({@link BaseError}) - If the sink is not found.
+     *
+     * @returns A new Logger instance without the removed sink.
+     */
+    unregisterSink<Key extends keyof TSinks>(name: Key): Logger<Omit<TSinks, Key>>;
+    /**
+     * Register multiple sinks at once.
+     *
+     * @template TNew - The new sinks to add.
+     *
+     * @param sinks - An array of tuples where each tuple contains the sink name and the sink instance.
+     *
+     * @throws ({@link BaseError}) - If any sink is already added.
+     *
+     * @returns A new Logger instance with the added sinks.
+     */
+    registerSinks<TNew extends [string, LoggerSink][] = [string, LoggerSink][]>(sinks: TNew): Logger<TSinks & {
+        [K in TNew[number][0]]: Extract<TNew[number], [K, LoggerSink]>[1];
     }>;
     /**
-    * Unregister multiple strategies at once.
-    *
-    * @template Keys - The names of the strategies to remove.
-    *
-    * @param names - An array of strategy names to remove.
-    *
-    * @throws ({@link BaseError}) - If any strategy is not found.
-    *
-    * @returns A new Logger instance without the removed strategies.
-    */
-    unregisterStrategies<Keys extends Extract<keyof TStrategies, string>>(names: Keys[]): Logger<Omit<TStrategies, Keys>>;
-    /**
-    * Remove all strategies.
-    *
-    * @returns A new Logger instance without any strategies.
-    */
-    clearStrategies(): Logger;
-    /**
-    * Log an error message.
-    *
-    * @template SNames - The names of the strategies to use.
-    *
-    * @param object - The object to log.
-    * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-    *
-    * @throws ({@link BaseError}) - If no strategy is added.
-    */
-    error<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-    * Log a warning message.
-    *
-    * @template SNames - The names of the strategies to use.
-    *
-    * @param object - The object to log.
-    * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-    *
-    * @throws ({@link BaseError}) - If no strategy is added.
-    */
-    warn<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-    * Log an info message.
-    *
-    * @template SNames - The names of the strategies to use.
-    *
-    * @param object - The object to log.
-    * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-    *
-    * @throws ({@link BaseError}) - If no strategy is added.
-    */
-    info<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-    * Log a debug message.
-    *
-    * @template SNames - The names of the strategies to use.
-    *
-    * @param object - The object to log.
-    * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-    *
-    * @throws ({@link BaseError}) - If no strategy is added.
-    */
-    debug<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-    * Log a generic message.
-    *
-    * @template SNames - The names of the strategies to use.
-    *
-    * @param object - The object to log.
-    * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-    *
-    * @throws ({@link BaseError}) - If no strategy is added.
-    */
-    log<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-    * Internal: execute all strategies for a log event.
-    *
-    * @template TLogObject - The type of the log object.
-    *
-    * @param level - The log level.
-    * @param date - The date of the log event.
-    * @param object - The object to log.
-    * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-    *
-    * @throws ({@link BaseError}) - If a strategy throws.
-    */
+     * Unregister multiple sinks at once.
+     *
+     * @template Keys - The names of the sinks to remove.
+     *
+     * @param names - An array of sink names to remove.
+     *
+     * @throws ({@link BaseError}) - If any sink is not found.
+     *
+     * @returns A new Logger instance without the removed sinks.
+     */
+    unregisterSinks<Keys extends Extract<keyof TSinks, string>>(names: Keys[]): Logger<Omit<TSinks, Keys>>;
+    /**
+     * Remove all sinks.
+     *
+     * @returns A new Logger instance without any sinks.
+     */
+    clearSinks(): Logger;
+    /**
+     * Log an error message.
+     *
+     * @template SNames - The names of the sinks to use.
+     *
+     * @param object - The object to log.
+     * @param sinksNames - The names of the sinks to use. If not provided, all sinks will be used.
+     *
+     * @throws ({@link BaseError}) - If no sink is added.
+     */
+    error<SNames extends (keyof TSinks)[] = (keyof TSinks)[]>(object: BodiesIntersection<TSinks, SNames[number]>, sinksNames?: SNames): void;
+    /**
+     * Log a warning message.
+     *
+     * @template SNames - The names of the sinks to use.
+     *
+     * @param object - The object to log.
+     * @param sinksNames - The names of the sinks to use. If not provided, all sinks will be used.
+     *
+     * @throws ({@link BaseError}) - If no sink is added.
+     */
+    warn<SNames extends (keyof TSinks)[] = (keyof TSinks)[]>(object: BodiesIntersection<TSinks, SNames[number]>, sinksNames?: SNames): void;
+    /**
+     * Log an info message.
+     *
+     * @template SNames - The names of the sinks to use.
+     *
+     * @param object - The object to log.
+     * @param sinksNames - The names of the sinks to use. If not provided, all sinks will be used.
+     *
+     * @throws ({@link BaseError}) - If no sink is added.
+     */
+    info<SNames extends (keyof TSinks)[] = (keyof TSinks)[]>(object: BodiesIntersection<TSinks, SNames[number]>, sinksNames?: SNames): void;
+    /**
+     * Log a debug message.
+     *
+     * @template SNames - The names of the sinks to use.
+     *
+     * @param object - The object to log.
+     * @param sinksNames - The names of the sinks to use. If not provided, all sinks will be used.
+     *
+     * @throws ({@link BaseError}) - If no sink is added.
+     */
+    debug<SNames extends (keyof TSinks)[] = (keyof TSinks)[]>(object: BodiesIntersection<TSinks, SNames[number]>, sinksNames?: SNames): void;
+    /**
+     * Log a generic message.
+     *
+     * @template SNames - The names of the sinks to use.
+     *
+     * @param object - The object to log.
+     * @param sinksNames - The names of the sinks to use. If not provided, all sinks will be used.
+     *
+     * @throws ({@link BaseError}) - If no sink is added.
+     */
+    log<SNames extends (keyof TSinks)[] = (keyof TSinks)[]>(object: BodiesIntersection<TSinks, SNames[number]>, sinksNames?: SNames): void;
+    /**
+     * Internal: execute all sinks for a log event.
+     *
+     * @template TLogObject - The type of the log object.
+     *
+     * @param level - The log level.
+     * @param date - The date of the log event.
+     * @param object - The object to log.
+     * @param sinksNames - The names of the sinks to use. If not provided, all sinks will be used.
+     *
+     * @throws ({@link BaseError}) - If a sink throws.
+     */
     private _executeStrategies;
     /**
-    * Internal: queue a log event and start writing if not already.
-    *
-    * @template TLogObject - The type of the log object.
-    *
-    * @param level - The log level.
-    * @param object - The object to log.
-    * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-    *
-    * @throws ({@link BaseError}) - If no strategy is added.
-    */
+     * Internal: queue a log event and start writing if not already.
+     *
+     * @template TLogObject - The type of the log object.
+     *
+     * @param level - The log level.
+     * @param object - The object to log.
+     * @param sinksNames - The names of the sinks to use. If not provided, all sinks will be used.
+     *
+     * @throws ({@link BaseError}) - If no sink is added.
+     */
     private _out;
     /**
-    * Internal: process the log queue and emit 'end' when done.
-    */
+     * Internal: process the log queue and emit 'end' when done.
+     */
     private _writeLog;
 }

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

@@ -0,0 +1,22 @@
+import type { LogLevels } from '../../../modules/logger/types/log-levels';
+import type { LoggerSink } from '../../../modules/logger/types/logger-sink';
+/**
+* ConsoleLoggerSink implements LoggerSink to provide logging functionality to the console.
+*/
+export declare class ConsoleLoggerSink implements LoggerSink {
+    private readonly _colorize;
+    /**
+    * Initializes the ConsoleLoggerSink.
+    *
+    * @param colorize - Indicates if the output should be colorized. (Default is false.)
+    */
+    constructor(colorize?: boolean);
+    /**
+    * Logs a message to the console with the specified log level.
+    *
+    * @param level - The log level at which the message should be logged.
+    * @param date - The date at which the message was logged.
+    * @param object - The object to log.
+    */
+    log(level: LogLevels, date: Date, object: unknown): void;
+}

package/dist/modules/logger/sinks/file-logger.d.ts

@@ -0,0 +1,25 @@
+import type { LogLevels } from '../../../modules/logger/types/log-levels';
+import type { LoggerSink } from '../../../modules/logger/types/logger-sink';
+/**
+* FileLoggerSink implements LoggerSink to provide logging functionality to the file system.
+*/
+export declare class FileLoggerSink implements LoggerSink {
+    /**
+    * Path to the file to log to.
+    */
+    private readonly _path;
+    /**
+    * Constructor FileLoggerSink
+    *
+    * @param path - Path to the file to log to.
+    */
+    constructor(path: string);
+    /**
+    * Logs a message to the file system with the specified log level.
+    *
+    * @param level - The log level at which the message should be logged.
+    * @param date - The date at which the message was logged.
+    * @param object - The object to log.
+    */
+    log(level: LogLevels, date: Date, object: unknown): Promise<void>;
+}

package/dist/modules/logger/sinks/index.d.ts

@@ -0,0 +1,2 @@
+export { ConsoleLoggerSink } from './console-logger.ts';
+export { FileLoggerSink } from './file-logger.ts';

package/dist/modules/logger/{strategies → sinks}/index.js

@@ -1,6 +1,6 @@
 // @bun
-// source/modules/logger/strategies/consoleLogger.ts
-class ConsoleLoggerStrategy {
+// source/modules/logger/sinks/console-logger.ts
+class ConsoleLoggerSink {
   _colorize;
   constructor(colorize = false) {
     this._colorize = colorize;
@@ -22,10 +22,10 @@ class ConsoleLoggerStrategy {
     console[level.toLowerCase()](message);
   }
 }
-// source/modules/logger/strategies/fileLogger.ts
+// source/modules/logger/sinks/file-logger.ts
 import { appendFile } from "fs/promises";
 
-class FileLoggerStrategy {
+class FileLoggerSink {
   _path;
   constructor(path) {
     this._path = path;
@@ -39,6 +39,6 @@ class FileLoggerStrategy {
   }
 }
 export {
-  FileLoggerStrategy,
-  ConsoleLoggerStrategy
+  FileLoggerSink,
+  ConsoleLoggerSink
 };

package/dist/modules/logger/types/bodies-intersection.d.ts

@@ -0,0 +1,2 @@
+import type { SinkBody } from './sink-body';
+export type BodiesIntersection<TSinks, K extends keyof TSinks> = (K extends unknown ? (object: SinkBody<TSinks, K>) => void : never) extends (object: infer I) => void ? I : never;

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

@@ -1,6 +1,6 @@
-export type { BodiesIntersection } from './bodiesIntersection.ts';
-export type { LoggerStrategy } from './loggerStrategy.ts';
-export type { LogLevels } from './logLevels.ts';
-export type { LogStreamChunk } from './logStreamChunk.ts';
-export type { StrategyBody } from './strategyBody.ts';
-export type { StrategyMap } from './strategyMap.ts';
+export type { BodiesIntersection } from './bodies-intersection.ts';
+export type { LogLevels } from './log-levels.ts';
+export type { LogStreamChunk } from './log-stream-chunk.ts';
+export type { LoggerSink } from './logger-sink.ts';
+export type { SinkBody } from './sink-body.ts';
+export type { SinkMap } from './sink-map.ts';

package/dist/modules/logger/types/log-stream-chunk.d.ts

@@ -0,0 +1,15 @@
+import type { LogLevels } from './log-levels';
+import type { SinkMap } from './sink-map';
+/**
+ * Internal log stream object for the queue.
+ */
+export interface LogStreamChunk<TLogObject, TSinks extends SinkMap> {
+    /** ISO date string of the log event. */
+    date: string;
+    /** Log level. */
+    level: LogLevels;
+    /** The object to log. */
+    object: TLogObject;
+    /** Names of sinks to use. */
+    sinksNames: (keyof TSinks)[];
+}

package/dist/modules/logger/types/{loggerStrategy.d.ts → logger-sink.d.ts}

@@ -1,7 +1,7 @@
-import type { LogLevels } from './logLevels';
-export interface LoggerStrategy<TLogObject = unknown> {
+import type { LogLevels } from './log-levels';
+export interface LoggerSink<TLogObject = unknown> {
     /**
-     * Logs a message with the strategy's implementation.
+     * Logs a message with the sink's implementation.
      *
      * @param level - The log level at which the message should be logged.
      * @param date - The date at which the message was logged.

package/dist/modules/logger/types/sink-body.d.ts

@@ -0,0 +1,2 @@
+import type { LoggerSink } from './logger-sink';
+export type SinkBody<TSink, Key extends keyof TSink> = TSink[Key] extends LoggerSink<infer TBody> ? TBody : never;

package/dist/modules/logger/types/sink-map.d.ts

@@ -0,0 +1,2 @@
+import type { LoggerSink } from './logger-sink';
+export type SinkMap = Record<string, LoggerSink>;

package/dist/modules/mailer/enums/index.d.ts

@@ -1 +1 @@
-export { MAILER_ERROR_KEYS } from './mailerErrorKeys';
+export { MAILER_ERROR_KEYS } from './mailer-error-keys';

package/dist/modules/mailer/enums/index.js

@@ -1,7 +1,7 @@
 // @bun
 import {
   MAILER_ERROR_KEYS
-} from "../../../chunk-45gt9273.js";
+} from "../../../chunk-5pwb7peq.js";
 export {
   MAILER_ERROR_KEYS
 };

package/dist/modules/mailer/index.js

@@ -1,10 +1,10 @@
 // @bun
 import {
   MAILER_ERROR_KEYS
-} from "../../chunk-45gt9273.js";
+} from "../../chunk-5pwb7peq.js";
 import {
   BaseError
-} from "../../chunk-vknq69e0.js";
+} from "../../chunk-9cgzhc50.js";
 
 // source/modules/mailer/smtp.ts
 import { createTransport } from "nodemailer";
@@ -20,7 +20,7 @@ class SMTP {
   }
   async connect() {
     if (this._transporter)
-      throw new BaseError({ message: MAILER_ERROR_KEYS.SMTP_ALREADY_CONNECTED });
+      throw new BaseError(MAILER_ERROR_KEYS.SMTP_ALREADY_CONNECTED);
     this._transporter = createTransport({
       host: this._config.host,
       port: this._config.port,
@@ -35,10 +35,7 @@ class SMTP {
     try {
       await this._transporter.verify();
     } catch (error) {
-      throw new BaseError({
-        message: MAILER_ERROR_KEYS.SMTP_CONNECTION_ERROR,
-        cause: error
-      });
+      throw new BaseError(MAILER_ERROR_KEYS.SMTP_CONNECTION_ERROR, error);
     }
   }
   disconnect() {
@@ -49,7 +46,7 @@ class SMTP {
   }
   async sendMail(options) {
     if (!this._transporter)
-      throw new BaseError({ message: MAILER_ERROR_KEYS.SMTP_NOT_CONNECTED });
+      throw new BaseError(MAILER_ERROR_KEYS.SMTP_NOT_CONNECTED);
     return this._transporter.sendMail(options);
   }
 }

package/dist/modules/mailer/smtp.d.ts

@@ -1,5 +1,5 @@
 import { type SendMailOptions } from 'nodemailer';
-import type { SMTPOptions } from './types/smtpOptions';
+import type { SMTPOptions } from './types/smtp-options';
 /**
  * The `SMTP` class manages the connection and operations with an SMTP server.
  *

package/dist/modules/mailer/types/index.d.ts

@@ -1,3 +1,3 @@
-export type { SMTPCredentials } from './smtpCredentials';
-export type { SMTPOptions } from './smtpOptions';
-export type { SMTPPoolOptions } from './smtpPoolOptions';
+export type { SMTPCredentials } from './smtp-credentials';
+export type { SMTPOptions } from './smtp-options';
+export type { SMTPPoolOptions } from './smtp-pool-options';

package/dist/modules/mailer/types/{smtpOptions.d.ts → smtp-options.d.ts}

@@ -1,5 +1,5 @@
-import type { SMTPCredentials } from './smtpCredentials';
-import type { SMTPPoolOptions } from './smtpPoolOptions';
+import type { SMTPCredentials } from './smtp-credentials';
+import type { SMTPPoolOptions } from './smtp-pool-options';
 export interface SMTPOptions {
     /**
      * The hostname or IP address of the SMTP server.

package/dist/modules/repository/index.js

@@ -1,12 +1,12 @@
 // @bun
 import {
   Repository
-} from "../../chunk-syhskygx.js";
-import"../../chunk-5qtpggzv.js";
-import"../../chunk-zaje5tv4.js";
-import"../../chunk-683sda6e.js";
-import"../../chunk-9nw6qekv.js";
-import"../../chunk-vknq69e0.js";
+} from "../../chunk-6g29g0tk.js";
+import"../../chunk-grfyngq0.js";
+import"../../chunk-c9vjf06h.js";
+import"../../chunk-00s6t4tw.js";
+import"../../chunk-h9t48r9q.js";
+import"../../chunk-9cgzhc50.js";
 export {
   Repository
 };

package/dist/modules/repository/repository.d.ts

@@ -1,11 +1,11 @@
 import type { Knex } from 'knex';
 import type { Table } from '../../modules/database/table';
-import type { StreamWithAsyncIterable } from '../../utils/types/streamWithAsyncIterable';
+import type { StreamWithAsyncIterable } from '../../shared/types/stream-with-async-iterable';
 import type { Filter } from './types/filter';
-import type { OrderByItem } from './types/orderByItem';
-import type { QueryOptions } from './types/queryOptions';
-import type { QueryOptionsExtendPagination } from './types/queryOptionsExtendPagination';
-import type { QueryOptionsExtendStream } from './types/queryOptionsExtendStream';
+import type { OrderByItem } from './types/order-by-item';
+import type { QueryOptions } from './types/query-options';
+import type { QueryOptionsExtendPagination } from './types/query-options-extend-pagination';
+import type { QueryOptionsExtendStream } from './types/query-options-extend-stream';
 /**
  * Repository allowing interaction with a database table using Knex.js fully typed.
  *

package/dist/modules/repository/types/filter.d.ts

@@ -1,5 +1,5 @@
-import type { AdaptiveWhereClause } from './adaptiveWhereClause';
-import type { SelectedFields } from './selectedFields';
+import type { AdaptiveWhereClause } from './adaptive-where-clause';
+import type { SelectedFields } from './selected-fields';
 /**
  * Defines an filter model using either plain partials of the model TModel or a {@link AdaptiveWhereClause} filter for more dynamic querying.
  *