@kalutskii/foundation 0.7.22 → 0.7.25

package/dist/index.d.ts

@@ -1,10 +1,9 @@
-import { SQL } from 'drizzle-orm';
-import { ErrorHandler, Context, TypedResponse, MiddlewareHandler } from 'hono';
-import * as kleur_colors from 'kleur/colors';
-import z$1, { z, ZodObject, ZodRawShape } from 'zod';
-import { Locale } from 'date-fns';
-import { SymmetricAlgorithm } from 'hono/utils/jwt/jwa';
-
+import { SQL } from "drizzle-orm";
+import { Locale } from "date-fns";
+import z, { ZodObject, ZodRawShape, z as z$1 } from "zod";
+import { Context, ErrorHandler, MiddlewareHandler, TypedResponse } from "hono";
+import { SymmetricAlgorithm } from "hono/utils/jwt/jwa";
+//#region src/drizzle/drizzle.refiners.d.ts
 /**
  * Builds a Drizzle `WHERE` clause by combining defined object entries with `and`.
  * Expects the supplied keys to be validated against the table beforehand.
@@ -13,58 +12,63 @@ import { SymmetricAlgorithm } from 'hono/utils/jwt/jwa';
  * await db.update(usersTable).set(values).where(sqlWhere(usersTable, { id: 1 })).returning();
  */
 declare function sqlWhere(table: unknown, where: Record<string, unknown>): SQL;
-
+//#endregion
+//#region src/hono/hono.execution.d.ts
 /**
  * Converts expected `HTTPException` values into shared API error envelopes.
  * Unexpected failures are logged and represented by a traceable generic response.
  */
 declare const onHandlerError: ErrorHandler;
-
+//#endregion
+//#region src/http/http.constants.d.ts
 declare const SUCCESS_STATUS_CODES: readonly [200, 201, 202, 307];
 declare const EXCEPTION_STATUS_CODES: readonly [400, 401, 403, 404, 405, 409, 500];
-
+//#endregion
+//#region src/http/http.types.d.ts
 type SuccessStatusCode = (typeof SUCCESS_STATUS_CODES)[number];
 type ExceptionStatusCode = (typeof EXCEPTION_STATUS_CODES)[number];
 type APISuccess<TData = void> = {
-    kind: 'data';
-    status: SuccessStatusCode;
-    data: TData;
+  kind: 'data';
+  status: SuccessStatusCode;
+  data: TData;
 };
 type APIError = {
-    kind: 'error';
-    status: ExceptionStatusCode;
-    error: string;
+  kind: 'error';
+  status: ExceptionStatusCode;
+  error: string;
 };
 type APIContractResult<TData = void> = APISuccess<TData> | APIError;
 type APIContractData<TResult extends APIContractResult<unknown>> = TResult extends APISuccess<infer TData> ? TData : never;
 type APIContractError<TResult extends APIContractResult<unknown>> = Extract<TResult, APIError>;
 type FetchResult<TData> = {
-    error: null;
-    data: TData;
+  error: null;
+  data: TData;
 } | {
-    error: string;
-    data: null;
+  error: string;
+  data: null;
 };
-
+//#endregion
+//#region src/hono/hono.types.d.ts
 /**
  * Options for a typed JSON response wrapped in the shared API success envelope.
  * The status generic preserves the literal code inferred by the route contract.
  */
 type HonoRespondOptions<TData extends object, TStatus extends SuccessStatusCode> = {
-    status: TStatus;
-    data?: TData;
+  status: TStatus;
+  data?: TData;
 };
 /**
  * Options for a downloadable binary response with attachment metadata.
  * The content type remains optional and falls back to a generic binary type.
  */
 type HonoFileRespondOptions<TStatus extends SuccessStatusCode> = {
-    status: TStatus;
-    content: Uint8Array<ArrayBuffer>;
-    filename: string;
-    contentType?: string;
+  status: TStatus;
+  content: Uint8Array<ArrayBuffer>;
+  filename: string;
+  contentType?: string;
 };
-
+//#endregion
+//#region src/hono/hono.respond.d.ts
 /**
  * Wraps `c.json` in the shared success envelope while preserving its literal status.
  * Missing response data is represented by an empty object for contract consistency.
@@ -75,7 +79,8 @@ declare function respond<T extends object = Record<string, never>, S extends Suc
  * Unknown/undefined content types default to `application/octet-stream`.
  */
 declare function fileRespond<S extends SuccessStatusCode>(c: Context, options: HonoFileRespondOptions<S>): Response;
-
+//#endregion
+//#region src/hmac/hmac.constants.d.ts
 /**
  * Default digest algorithm used by `HMACService` when none is configured.
  * SHA-256 provides broad Web Crypto support and a 256-bit authentication tag.
@@ -86,32 +91,34 @@ declare const DEFAULT_HMAC_ALGORITHM: "SHA-256";
  * Hex output remains deterministic, portable, and independent of padding rules.
  */
 declare const DEFAULT_HMAC_ENCODING: "hex";
-
-declare const hmacAlgorithmsArray: readonly ["SHA-256", "SHA-384", "SHA-512"];
+//#endregion
+//#region src/hmac/hmac.enums.d.ts
+declare const hmacAlgorithmsArray: readonly ['SHA-256', 'SHA-384', 'SHA-512'];
 type HMACAlgorithm = (typeof hmacAlgorithmsArray)[number];
 declare const hmacAlgorithmsRecord: Readonly<{
-    SHA_256: "SHA-256";
-    SHA_384: "SHA-384";
-    SHA_512: "SHA-512";
+  SHA_256: "SHA-256";
+  SHA_384: "SHA-384";
+  SHA_512: "SHA-512";
 }>;
 declare const hmacAlgorithm: Readonly<{
-    SHA_256: "SHA-256";
-    SHA_384: "SHA-384";
-    SHA_512: "SHA-512";
+  SHA_256: "SHA-256";
+  SHA_384: "SHA-384";
+  SHA_512: "SHA-512";
 }>;
-declare const hmacEncodingsArray: readonly ["hex", "base64", "base64url"];
+declare const hmacEncodingsArray: readonly ['hex', 'base64', 'base64url'];
 type HMACEncoding = (typeof hmacEncodingsArray)[number];
 declare const hmacEncodingsRecord: Readonly<{
-    HEX: "hex";
-    BASE64: "base64";
-    BASE64URL: "base64url";
+  BASE64: "base64";
+  BASE64URL: "base64url";
+  HEX: "hex";
 }>;
 declare const hmacEncoding: Readonly<{
-    HEX: "hex";
-    BASE64: "base64";
-    BASE64URL: "base64url";
+  BASE64: "base64";
+  BASE64URL: "base64url";
+  HEX: "hex";
 }>;
-
+//#endregion
+//#region src/hmac/hmac.types.d.ts
 /**
  * Binary-safe input accepted as either an HMAC payload or a secret key.
  * Strings use UTF-8 encoding while byte arrays preserve their exact contents.
@@ -122,45 +129,47 @@ type HMACInput = string | Uint8Array;
  * Omitted values select SHA-256 and lowercase hexadecimal output by default.
  */
 type HMACServiceOptions = Readonly<{
-    /**
-     * Web Crypto digest algorithm used to authenticate every payload.
-     * The service defaults to `SHA-256` when this option is omitted.
-     */
-    algorithm?: HMACAlgorithm;
-    /**
-     * Text encoding applied to generated and verified signatures.
-     * The service defaults to `hex` when this option is omitted.
-     */
-    encoding?: HMACEncoding;
+  /**
+   * Web Crypto digest algorithm used to authenticate every payload.
+   * The service defaults to `SHA-256` when this option is omitted.
+   */
+  algorithm?: HMACAlgorithm;
+  /**
+   * Text encoding applied to generated and verified signatures.
+   * The service defaults to `hex` when this option is omitted.
+   */
+  encoding?: HMACEncoding;
 }>;
-
+//#endregion
+//#region src/hmac/hmac.services.d.ts
 /**
  * Creates and verifies keyed message authentication codes through Web Crypto.
  * Each instance preserves its digest algorithm and textual encoding configuration.
  */
 declare class HMACService {
-    readonly algorithm: HMACAlgorithm;
-    readonly encoding: HMACEncoding;
-    constructor(options?: HMACServiceOptions);
-    /**
-     * Authenticates a payload with a secret and returns the encoded signature.
-     * String inputs use UTF-8 while byte arrays preserve their exact byte sequence.
-     *
-     * @example
-     * const signature = await hmacService.sign('payload', 'shared-secret');
-     */
-    sign(payload: HMACInput, secret: HMACInput): Promise<string>;
-    /**
-     * Verifies an encoded signature without requiring a manual equality comparison.
-     * Invalid encodings, incorrect secrets, and altered payloads all resolve to `false`.
-     *
-     * @example
-     * const verified = await hmacService.verify('payload', signature, 'shared-secret');
-     */
-    verify(payload: HMACInput, signature: string, secret: HMACInput): Promise<boolean>;
-    private importSecret;
+  readonly algorithm: HMACAlgorithm;
+  readonly encoding: HMACEncoding;
+  constructor(options?: HMACServiceOptions);
+  /**
+   * Authenticates a payload with a secret and returns the encoded signature.
+   * String inputs use UTF-8 while byte arrays preserve their exact byte sequence.
+   *
+   * @example
+   * const signature = await hmacService.sign('payload', 'shared-secret');
+   */
+  sign(payload: HMACInput, secret: HMACInput): Promise<string>;
+  /**
+   * Verifies an encoded signature without requiring a manual equality comparison.
+   * Invalid encodings, incorrect secrets, and altered payloads all resolve to `false`.
+   *
+   * @example
+   * const verified = await hmacService.verify('payload', signature, 'shared-secret');
+   */
+  verify(payload: HMACInput, signature: string, secret: HMACInput): Promise<boolean>;
+  private importSecret;
 }
-
+//#endregion
+//#region src/hmac/hmac.utilities.d.ts
 /**
  * Converts an HMAC payload or secret into an isolated byte array representation.
  * Strings use UTF-8 while supplied bytes are copied to prevent later mutation.
@@ -176,24 +185,26 @@ declare function encodeHMACSignature(signature: Uint8Array, encoding: HMACEncodi
  * Malformed alphabets, lengths, or padding combinations reject with `TypeError`.
  */
 declare function decodeHMACSignature(signature: string, encoding: HMACEncoding): Uint8Array<ArrayBuffer>;
-
+//#endregion
+//#region src/http/http.factory.d.ts
 /**
  * Creates a successful API envelope without cloning its data.
  * Generic inference preserves the exact supplied payload type.
  */
 declare function success<T = unknown>({ status, data }: {
-    status: SuccessStatusCode;
-    data: T;
+  status: SuccessStatusCode;
+  data: T;
 }): APISuccess<T>;
 /**
  * Creates a failed API envelope with one supported exception status.
  * The supplied message remains unchanged for downstream presentation.
  */
 declare function failure({ status, error }: {
-    status: ExceptionStatusCode;
-    error: string;
+  status: ExceptionStatusCode;
+  error: string;
 }): APIError;
-
+//#endregion
+//#region src/http/http.resolvers.d.ts
 /**
  * Converts an API contract envelope into a mutually exclusive safe result.
  * Only `APIError` values are normalized; rejected fetchers still reject.
@@ -204,15 +215,16 @@ declare function fetchSafely<TResult extends APIContractResult<unknown>>(fetcher
  * Rejected fetchers propagate their original error without replacement.
  */
 declare function fetchAndThrow<TResult extends APIContractResult<unknown>>(fetcher: () => Promise<TResult>): Promise<APIContractData<TResult>>;
-
+//#endregion
+//#region src/logging/logging.constants.d.ts
 /**
  * Terminal color configuration for every supported logging level.
  * The `LogLevel` contract prevents missing or unsupported level entries.
  */
 declare const logLevelColors: {
-    readonly info: typeof kleur_colors.print;
-    readonly warn: typeof kleur_colors.print;
-    readonly error: typeof kleur_colors.print;
+  readonly info: typeof import("kleur/colors").print;
+  readonly warn: typeof import("kleur/colors").print;
+  readonly error: typeof import("kleur/colors").print;
 };
 /**
  * Public placeholder written instead of sensitive query and JSON values.
@@ -223,41 +235,44 @@ declare const REDACTED_LOG_VALUE = "[redacted]";
  * Normalized key fragments treated as sensitive by logging redaction.
  * Matching ignores case and separators so compound field names remain covered.
  */
-declare const sensitiveLogKeyParts: readonly ["password", "passwd", "token", "secret", "authorization", "apikey", "credential"];
+declare const sensitiveLogKeyParts: readonly ['password', 'passwd', 'token', 'secret', 'authorization', 'apikey', 'credential'];
 /**
  * Terminal colors assigned to the supported HTTP response status ranges.
  * Unlisted ranges intentionally retain the terminal's default text appearance.
  */
 declare const httpStatusColors: readonly [{
-    readonly range: readonly [200, 299];
-    readonly color: typeof kleur_colors.print;
+  readonly range: readonly [200, 299];
+  readonly color: typeof import("kleur/colors").print;
 }, {
-    readonly range: readonly [400, 499];
-    readonly color: typeof kleur_colors.print;
+  readonly range: readonly [400, 499];
+  readonly color: typeof import("kleur/colors").print;
 }, {
-    readonly range: readonly [500, 599];
-    readonly color: typeof kleur_colors.print;
+  readonly range: readonly [500, 599];
+  readonly color: typeof import("kleur/colors").print;
 }];
-
-declare const logLevelsArray: readonly ["info", "warn", "error"];
+//#endregion
+//#region src/logging/logging.enums.d.ts
+declare const logLevelsArray: readonly ['info', 'warn', 'error'];
 type LogLevel = (typeof logLevelsArray)[number];
 declare const logLevelsRecord: Readonly<{
-    ERROR: "error";
-    INFO: "info";
-    WARN: "warn";
+  ERROR: "error";
+  INFO: "info";
+  WARN: "warn";
 }>;
 declare const logLevel: Readonly<{
-    ERROR: "error";
-    INFO: "info";
-    WARN: "warn";
+  ERROR: "error";
+  INFO: "info";
+  WARN: "warn";
 }>;
-
+//#endregion
+//#region src/logging/logging.middleware.d.ts
 /**
  * Logs Hono request metadata with query parameters and a normalized body preview.
  * Sensitive values are redacted by partial key match before output is written.
  */
 declare const loggingMiddleware: MiddlewareHandler;
-
+//#endregion
+//#region src/logging/logging.security.d.ts
 /**
  * Replaces sensitive query values using partial, case-insensitive key matching.
  * A new collection is returned so the caller's search parameters remain unchanged.
@@ -268,217 +283,223 @@ declare function redactSensitiveSearchParams(searchParams: URLSearchParams): URL
  * Invalid JSON and payloads without matching keys are returned byte-for-byte unchanged.
  */
 declare function redactSensitiveJSON(json: string): string;
-
+//#endregion
+//#region src/logging/logging.services.d.ts
 /**
  * Writes timestamped and colorized messages using a stable service column.
  * Error messages may include a stack trace on a subordinate second line.
  */
 declare const log: {
-    /**
-     * Writes an informational message with an optional service label.
-     * Missing service names use the shared `log` fallback label.
-     */
-    info(message: string, service?: string): void;
-    /**
-     * Writes a warning message with an optional service label.
-     * Missing service names use the shared `log` fallback label.
-     */
-    warn(message: string, service?: string): void;
-    /**
-     * Writes an error message with optional service and stack trace context.
-     * Provided stack traces are rendered beneath the primary message.
-     */
-    error(message: string, service?: string, stack?: string): void;
+  /**
+   * Writes an informational message with an optional service label.
+   * Missing service names use the shared `log` fallback label.
+   */
+  info(message: string, service?: string): void;
+  /**
+   * Writes a warning message with an optional service label.
+   * Missing service names use the shared `log` fallback label.
+   */
+  warn(message: string, service?: string): void;
+  /**
+   * Writes an error message with optional service and stack trace context.
+   * Provided stack traces are rendered beneath the primary message.
+   */
+  error(message: string, service?: string, stack?: string): void;
 };
-
+//#endregion
+//#region src/logging/logging.utilities.d.ts
 /**
  * Selects a terminal color function for one HTTP response status.
  * Successes are green, client errors yellow, and server errors red.
  */
 declare function getColoredHTTPStatus(status: number): (text: string) => string;
-
+//#endregion
+//#region src/upload/upload.constants.d.ts
 /**
  * Canonical metadata shared by upload controls and runtime validation.
  * Every supported format defines display, MIME, and extension values.
  */
 declare const fileFormatsConfig: {
-    readonly png: {
-        readonly name: "PNG";
-        readonly mimeTypes: readonly ["image/png"];
-        readonly extensions: readonly [".png"];
-    };
-    readonly jpg: {
-        readonly name: "JPG";
-        readonly mimeTypes: readonly ["image/jpeg"];
-        readonly extensions: readonly [".jpg", ".jpeg"];
-    };
-    readonly svg: {
-        readonly name: "SVG";
-        readonly mimeTypes: readonly ["image/svg+xml"];
-        readonly extensions: readonly [".svg"];
-    };
-    readonly webp: {
-        readonly name: "WEBP";
-        readonly mimeTypes: readonly ["image/webp"];
-        readonly extensions: readonly [".webp"];
-    };
-    readonly avif: {
-        readonly name: "AVIF";
-        readonly mimeTypes: readonly ["image/avif"];
-        readonly extensions: readonly [".avif"];
-    };
-    readonly heic: {
-        readonly name: "HEIC";
-        readonly mimeTypes: readonly ["image/heic", "image/heif"];
-        readonly extensions: readonly [".heic", ".heif"];
-    };
-    readonly pdf: {
-        readonly name: "PDF";
-        readonly mimeTypes: readonly ["application/pdf"];
-        readonly extensions: readonly [".pdf"];
-    };
-    readonly rtf: {
-        readonly name: "RTF";
-        readonly mimeTypes: readonly ["application/rtf"];
-        readonly extensions: readonly [".rtf"];
-    };
-    readonly txt: {
-        readonly name: "TXT";
-        readonly mimeTypes: readonly ["text/plain"];
-        readonly extensions: readonly [".txt"];
-    };
+  readonly png: {
+    readonly name: 'PNG';
+    readonly mimeTypes: readonly ["image/png"];
+    readonly extensions: readonly [".png"];
+  };
+  readonly jpg: {
+    readonly name: 'JPG';
+    readonly mimeTypes: readonly ["image/jpeg"];
+    readonly extensions: readonly [".jpg", ".jpeg"];
+  };
+  readonly svg: {
+    readonly name: 'SVG';
+    readonly mimeTypes: readonly ["image/svg+xml"];
+    readonly extensions: readonly [".svg"];
+  };
+  readonly webp: {
+    readonly name: 'WEBP';
+    readonly mimeTypes: readonly ["image/webp"];
+    readonly extensions: readonly [".webp"];
+  };
+  readonly avif: {
+    readonly name: 'AVIF';
+    readonly mimeTypes: readonly ["image/avif"];
+    readonly extensions: readonly [".avif"];
+  };
+  readonly heic: {
+    readonly name: 'HEIC';
+    readonly mimeTypes: readonly ["image/heic", "image/heif"];
+    readonly extensions: readonly [".heic", ".heif"];
+  };
+  readonly pdf: {
+    readonly name: 'PDF';
+    readonly mimeTypes: readonly ["application/pdf"];
+    readonly extensions: readonly [".pdf"];
+  };
+  readonly rtf: {
+    readonly name: 'RTF';
+    readonly mimeTypes: readonly ["application/rtf"];
+    readonly extensions: readonly [".rtf"];
+  };
+  readonly txt: {
+    readonly name: 'TXT';
+    readonly mimeTypes: readonly ["text/plain"];
+    readonly extensions: readonly [".txt"];
+  };
 };
-
+//#endregion
+//#region src/upload/upload.enums.d.ts
 declare const fileFormatsArray: readonly ["png", "jpg", "webp", "avif", "heic", "svg", "pdf", "rtf", "txt"];
 type FileFormat = (typeof fileFormatsArray)[number];
 declare const fileFormatsRecord: Readonly<{
-    AVIF: "avif";
-    JPG: "jpg";
-    PDF: "pdf";
-    PNG: "png";
-    RTF: "rtf";
-    SVG: "svg";
-    TXT: "txt";
-    WEBP: "webp";
-    HEIC: "heic";
+  AVIF: "avif";
+  HEIC: "heic";
+  JPG: "jpg";
+  PDF: "pdf";
+  PNG: "png";
+  RTF: "rtf";
+  SVG: "svg";
+  TXT: "txt";
+  WEBP: "webp";
 }>;
 declare const fileFormat: Readonly<{
-    AVIF: "avif";
-    JPG: "jpg";
-    PDF: "pdf";
-    PNG: "png";
-    RTF: "rtf";
-    SVG: "svg";
-    TXT: "txt";
-    WEBP: "webp";
-    HEIC: "heic";
+  AVIF: "avif";
+  HEIC: "heic";
+  JPG: "jpg";
+  PDF: "pdf";
+  PNG: "png";
+  RTF: "rtf";
+  SVG: "svg";
+  TXT: "txt";
+  WEBP: "webp";
 }>;
-declare const uploadValidationErrorsArray: readonly ["empty_file", "unsupported_file_format", "file_size_exceeded", "files_count_exceeded"];
+declare const uploadValidationErrorsArray: readonly ['empty_file', 'unsupported_file_format', 'file_size_exceeded', 'files_count_exceeded'];
 type UploadValidationError = (typeof uploadValidationErrorsArray)[number];
 declare const uploadValidationErrorsRecord: Readonly<{
-    EMPTY_FILE: "empty_file";
-    UNSUPPORTED_FILE_FORMAT: "unsupported_file_format";
-    FILE_SIZE_EXCEEDED: "file_size_exceeded";
-    FILES_COUNT_EXCEEDED: "files_count_exceeded";
+  EMPTY_FILE: "empty_file";
+  FILES_COUNT_EXCEEDED: "files_count_exceeded";
+  FILE_SIZE_EXCEEDED: "file_size_exceeded";
+  UNSUPPORTED_FILE_FORMAT: "unsupported_file_format";
 }>;
 declare const uploadValidationError: Readonly<{
-    EMPTY_FILE: "empty_file";
-    UNSUPPORTED_FILE_FORMAT: "unsupported_file_format";
-    FILE_SIZE_EXCEEDED: "file_size_exceeded";
-    FILES_COUNT_EXCEEDED: "files_count_exceeded";
+  EMPTY_FILE: "empty_file";
+  FILES_COUNT_EXCEEDED: "files_count_exceeded";
+  FILE_SIZE_EXCEEDED: "file_size_exceeded";
+  UNSUPPORTED_FILE_FORMAT: "unsupported_file_format";
 }>;
-
+//#endregion
+//#region src/upload/upload.types.d.ts
 type FileFormatConfig = (typeof fileFormatsConfig)[FileFormat];
 /**
  * Shared upload policy consumed by browser controls and backend validation.
  * One preset keeps format, size, capacity, and fallback rules synchronized.
  */
 type UploadPreset<TFormats extends readonly FileFormat[] = readonly FileFormat[]> = Readonly<{
-    /**
-     * Supported formats accepted by every consumer of the preset.
-     * Const inference preserves the supplied format tuple without widening.
-     */
-    formats: TFormats;
-    /**
-     * Maximum accepted size of one uploaded file measured in bytes.
-     * Schema and client validation can share this exact numeric boundary.
-     */
-    maxFileSize: number;
-    /**
-     * Optional maximum number of files retained by one upload collection.
-     * Single-file controls can set this value to `1` for shared capacity rules.
-     */
-    maxFilesCount?: number;
-    /**
-     * Allows extensions to compensate for absent or unreliable MIME metadata.
-     * The fallback remains disabled when this option is omitted.
-     */
-    extensionFallback?: boolean;
+  /**
+   * Supported formats accepted by every consumer of the preset.
+   * Const inference preserves the supplied format tuple without widening.
+   */
+  formats: TFormats;
+  /**
+   * Maximum accepted size of one uploaded file measured in bytes.
+   * Schema and client validation can share this exact numeric boundary.
+   */
+  maxFileSize: number;
+  /**
+   * Optional maximum number of files retained by one upload collection.
+   * Single-file controls can set this value to `1` for shared capacity rules.
+   */
+  maxFilesCount?: number;
+  /**
+   * Allows extensions to compensate for absent or unreliable MIME metadata.
+   * The fallback remains disabled when this option is omitted.
+   */
+  extensionFallback?: boolean;
 }>;
 /**
  * Constraints used to validate an incoming collection of browser files.
  * Existing and incoming counts are combined when enforcing capacity.
  */
 type UploadFilesValidationOptions = Readonly<{
-    /**
-     * Number of files already retained before the incoming batch is validated.
-     * Existing entries reduce the remaining capacity without being revalidated.
-     */
-    currentFilesCount: number;
-    /**
-     * Supported formats used to validate every file in the incoming batch.
-     * MIME and extension metadata are resolved through the canonical catalog.
-     */
-    formats: readonly FileFormat[];
-    /**
-     * Maximum accepted size of one uploaded file measured in bytes.
-     * Files exceeding this boundary receive the stable size error key.
-     */
-    maxFileSize: number;
-    /**
-     * Optional maximum number of retained files after accepting the batch.
-     * Omitting this value leaves collection capacity unrestricted.
-     */
-    maxFilesCount?: number;
+  /**
+   * Number of files already retained before the incoming batch is validated.
+   * Existing entries reduce the remaining capacity without being revalidated.
+   */
+  currentFilesCount: number;
+  /**
+   * Supported formats used to validate every file in the incoming batch.
+   * MIME and extension metadata are resolved through the canonical catalog.
+   */
+  formats: readonly FileFormat[];
+  /**
+   * Maximum accepted size of one uploaded file measured in bytes.
+   * Files exceeding this boundary receive the stable size error key.
+   */
+  maxFileSize: number;
+  /**
+   * Optional maximum number of retained files after accepting the batch.
+   * Omitting this value leaves collection capacity unrestricted.
+   */
+  maxFilesCount?: number;
 }>;
 /**
  * Accepted files and the final rejection encountered in one batch.
  * Valid entries remain available when another entry fails validation.
  */
 type UploadFilesValidationResult = Readonly<{
-    /**
-     * Valid incoming files that fit the remaining collection capacity.
-     * Accepted file objects preserve their original identity and ordering.
-     */
-    acceptedFiles: File[];
-    /**
-     * Final stable rejection encountered while processing the incoming batch.
-     * The field remains absent when every supplied file is accepted.
-     */
-    validationError?: UploadValidationError;
+  /**
+   * Valid incoming files that fit the remaining collection capacity.
+   * Accepted file objects preserve their original identity and ordering.
+   */
+  acceptedFiles: File[];
+  /**
+   * Final stable rejection encountered while processing the incoming batch.
+   * The field remains absent when every supplied file is accepted.
+   */
+  validationError?: UploadValidationError;
 }>;
 /**
  * Options used to construct one reusable Zod file schema.
  * Extension fallback is disabled by default to preserve strict MIME checks.
  */
 type ZodUploadFileSchemaOptions = Readonly<{
-    /**
-     * Supported formats accepted by the generated file schema.
-     * Strict MIME validation uses metadata from the canonical format catalog.
-     */
-    formats: readonly FileFormat[];
-    /**
-     * Maximum accepted file size measured in bytes for the generated file schema.
-     * Empty files remain invalid independently of this configured boundary.
-     */
-    maxFileSize: number;
-    /**
-     * Allows a supported extension to compensate for missing MIME metadata.
-     * The fallback remains disabled by default to preserve strict validation.
-     */
-    extensionFallback?: boolean;
+  /**
+   * Supported formats accepted by the generated file schema.
+   * Strict MIME validation uses metadata from the canonical format catalog.
+   */
+  formats: readonly FileFormat[];
+  /**
+   * Maximum accepted file size measured in bytes for the generated file schema.
+   * Empty files remain invalid independently of this configured boundary.
+   */
+  maxFileSize: number;
+  /**
+   * Allows a supported extension to compensate for missing MIME metadata.
+   * The fallback remains disabled by default to preserve strict validation.
+   */
+  extensionFallback?: boolean;
 }>;
-
+//#endregion
+//#region src/upload/upload.factory.d.ts
 /**
  * Defines one shared upload policy while preserving its literal format tuple.
  * The resulting preset can drive schemas, picker hints, and batch validation.
@@ -491,7 +512,8 @@ type ZodUploadFileSchemaOptions = Readonly<{
  * });
  */
 declare function defineUploadPreset<const TFormats extends readonly FileFormat[]>(preset: UploadPreset<TFormats>): UploadPreset<TFormats>;
-
+//#endregion
+//#region src/upload/upload.presets.d.ts
 /**
  * Default maximum size of one file accepted by the built-in upload presets.
  * The 20 MiB boundary matches the existing upload component policy.
@@ -502,38 +524,40 @@ declare const DEFAULT_UPLOAD_MAX_FILE_SIZE: number;
  * Each image may occupy up to 20 MiB while collection capacity remains unrestricted.
  */
 declare const imageUploadPreset: Readonly<{
-    formats: readonly ["png", "jpg", "webp", "avif", "heic"];
-    maxFileSize: number;
-    maxFilesCount?: number;
-    extensionFallback?: boolean;
+  formats: readonly ["png", "jpg", "webp", "avif", "heic"];
+  maxFileSize: number;
+  maxFilesCount?: number;
+  extensionFallback?: boolean;
 }>;
 /**
  * Ready-to-use policy for every image format supporting transparency (alpha channel).
  * Each image may occupy up to 20 MiB while collection capacity remains unrestricted.
  */
 declare const imageTransparentUploadPreset: Readonly<{
-    formats: readonly ["png", "webp", "svg"];
-    maxFileSize: number;
-    maxFilesCount?: number;
-    extensionFallback?: boolean;
+  formats: readonly ["png", "webp", "svg"];
+  maxFileSize: number;
+  maxFilesCount?: number;
+  extensionFallback?: boolean;
 }>;
 /**
  * Ready-to-use policy for every document format supported by the upload catalog.
  * Each document may occupy up to 20 MiB while collection capacity remains unrestricted.
  */
 declare const documentUploadPreset: Readonly<{
-    formats: readonly ["pdf", "rtf", "txt"];
-    maxFileSize: number;
-    maxFilesCount?: number;
-    extensionFallback?: boolean;
+  formats: readonly ["pdf", "rtf", "txt"];
+  maxFileSize: number;
+  maxFilesCount?: number;
+  extensionFallback?: boolean;
 }>;
-
+//#endregion
+//#region src/upload/upload.schemas.d.ts
 /**
  * Builds a reusable Zod schema for one uploaded file with format and size.
  * MIME matching is strict unless extension fallback is explicitly enabled.
  */
-declare function zodUploadFileSchema(options: ZodUploadFileSchemaOptions): z.ZodFile;
-
+declare function zodUploadFileSchema(options: ZodUploadFileSchemaOptions): z$1.ZodFile;
+//#endregion
+//#region src/upload/upload.utilities.d.ts
 /**
  * Extracts a normalized trailing extension from a complete file name.
  * Returns an empty string when no valid dot-delimited suffix exists.
@@ -569,7 +593,8 @@ declare function isFileFormatSupported(file: File, formats: readonly FileFormat[
  * Duplicate values are removed while their configuration order is retained.
  */
 declare function createUploadAccept(formats: readonly FileFormat[]): string;
-
+//#endregion
+//#region src/upload/upload.validation.d.ts
 /**
  * Validates one file against configured format and size constraints.
  * Returns the first stable error key or nothing for a valid file.
@@ -580,7 +605,8 @@ declare function validateUploadFile(file: File, formats: readonly FileFormat[],
  * Returns accepted entries and the final rejection key from the batch.
  */
 declare function validateUploadFiles(incomingFiles: readonly File[], options: UploadFilesValidationOptions): UploadFilesValidationResult;
-
+//#endregion
+//#region src/utilities/datetime.utilities.d.ts
 /**
  * Projects the current instant onto the wall-clock fields of another timezone.
  * The timezone defaults to `Europe/London` when no option is provided.
@@ -589,7 +615,7 @@ declare function validateUploadFiles(incomingFiles: readonly File[], options: Up
  * const londonTime = getZonedTime({ tz: 'Europe/London' });
  */
 declare function getZonedTime({ tz }?: {
-    tz?: string;
+  tz?: string;
 }): Date;
 /**
  * Formats the UTC offset of a timezone at the supplied date.
@@ -607,7 +633,7 @@ declare function getUTCOffset(date: Date, tz: string): string;
  * getFormattedTime({ tz: 'Europe/Moscow' }); // `03:04:05 (+3 UTC)`
  */
 declare function getFormattedTime({ tz }?: {
-    tz?: string;
+  tz?: string;
 }): string;
 /**
  * Formats the current date with optional time and UTC offset components.
@@ -616,9 +642,9 @@ declare function getFormattedTime({ tz }?: {
  * @example
  * getFormattedDate({ tz: 'UTC', withTime: false }); // `02.01.2024`
  */
-declare function getFormattedDate({ tz, withTime, }?: {
-    tz?: string;
-    withTime?: boolean;
+declare function getFormattedDate({ tz, withTime }?: {
+  tz?: string;
+  withTime?: boolean;
 }): string;
 /**
  * Formats an explicit instant in another timezone using the selected locale.
@@ -628,10 +654,11 @@ declare function getFormattedDate({ tz, withTime, }?: {
  * formatTime(date, { locale: ru, tz: 'Europe/Moscow' });
  */
 declare function formatTime(time: Date, { locale, tz }?: {
-    locale?: Locale;
-    tz?: string;
+  locale?: Locale;
+  tz?: string;
 }): string;
-
+//#endregion
+//#region src/utilities/encoding.utilities.d.ts
 /**
  * Encodes arbitrary binary bytes into their canonical Base64 representation.
  * Chunked conversion avoids the argument limit imposed by `String.fromCharCode`.
@@ -642,7 +669,8 @@ declare function encodeBase64(bytes: Uint8Array): string;
  * Invalid input preserves the native `atob` failure instead of returning partial data.
  */
 declare function decodeBase64(value: string): Uint8Array<ArrayBuffer>;
-
+//#endregion
+//#region src/utilities/enums.utilities.d.ts
 /**
  * Recursively replaces dots in a string literal with underscores.
  * Every other character remains unchanged in the resulting literal type.
@@ -666,9 +694,7 @@ type ReplaceHyphensWithUnderscores<TValue extends string> = TValue extends `${in
  * @example
  * type Statuses = StringEnumRecord<readonly ['review.pending', 'published']>;
  */
-type StringEnumRecord<TValues extends readonly string[]> = Readonly<{
-    [Value in TValues[number] as Uppercase<ReplaceHyphensWithUnderscores<ReplaceDotsWithUnderscores<Value>>>]: Value;
-}>;
+type StringEnumRecord<TValues extends readonly string[]> = Readonly<{ [Value in TValues[number] as Uppercase<ReplaceHyphensWithUnderscores<ReplaceDotsWithUnderscores<Value>>>]: Value; }>;
 /**
  * Creates an immutable enum-like record from a readonly string array.
  * Keys are uppercased and every dot or hyphen is replaced with an underscore.
@@ -677,7 +703,8 @@ type StringEnumRecord<TValues extends readonly string[]> = Readonly<{
  * createStringEnumRecord(['foo-bar.s', 'baz'] as const); // `{ FOO_BAR_S: 'foo-bar.s', BAZ: 'baz' }`
  */
 declare function createStringEnumRecord<const T extends readonly string[]>(values: T): StringEnumRecord<T>;
-
+//#endregion
+//#region src/utilities/execution.utilities.d.ts
 /**
  * Resolves synchronous and asynchronous executions through one promise-based contract.
  * Failures use the supplied fallback or propagate unchanged when none is available.
@@ -691,16 +718,16 @@ declare function safeExecute<T, E = never>(fn: () => Promise<T> | T, onError?: (
  * The original value is preserved beside its rounded millisecond duration.
  */
 type MeasuredExecution<T> = {
-    /**
-     * Value resolved by the measured execution without cloning or transformation.
-     * Its generic type remains identical to the original asynchronous result.
-     */
-    result: T;
-    /**
-     * Rounded wall-clock duration of the measured execution in milliseconds.
-     * The value is always collected after the supplied promise resolves.
-     */
-    executionTime: number;
+  /**
+   * Value resolved by the measured execution without cloning or transformation.
+   * Its generic type remains identical to the original asynchronous result.
+   */
+  result: T;
+  /**
+   * Rounded wall-clock duration of the measured execution in milliseconds.
+   * The value is always collected after the supplied promise resolves.
+   */
+  executionTime: number;
 };
 /**
  * Measures an asynchronous execution while preserving its resolved result.
@@ -713,7 +740,8 @@ type MeasuredExecution<T> = {
  * console.log(`Execution time: ${executionTime}ms`);
  */
 declare function measureExecutionTime<T>(execution: () => Promise<T>): Promise<MeasuredExecution<T>>;
-
+//#endregion
+//#region src/utilities/generation.utilities.d.ts
 /**
  * Creates a cryptographically sourced string from the alphanumeric set.
  * Requested length defaults to `10` characters when omitted.
@@ -723,15 +751,15 @@ declare function measureExecutionTime<T>(execution: () => Promise<T>): Promise<M
  * generateRandomString(); // `G5kLm2P9sQ`
  */
 declare function generateRandomString(length?: number): string;
-
+//#endregion
+//#region src/utilities/type.utilities.d.ts
 /**
  * Utility type that simplifies a given type T by flattening its structure.
  * This is particularly useful for improving the readability of complex types.
  */
-type Simplify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-
+type Simplify<T> = { [K in keyof T]: T[K]; } & {};
+//#endregion
+//#region src/zod-bulk/zod-bulk.schemas.d.ts
 /**
  * Builds a strict selection contract for bulk operations across paginated data.
  * The identifier schema is shared by explicit and all-matching selection modes.
@@ -744,150 +772,155 @@ type Simplify<T> = {
  *   identifierSchema: z.string().min(1),
  * });
  */
-declare function zodBulkSelectionSchema<const TIdentifierSchema extends z.ZodType<string | number>>({ identifierSchema, }: {
-    /**
-     * Schema used to validate every included or excluded entity identifier.
-     * Its transforms and exact inferred output are preserved in both branches.
-     */
-    identifierSchema: TIdentifierSchema;
-}): z.ZodDiscriminatedUnion<[z.ZodObject<{
-    mode: z.ZodLiteral<"include">;
-    identifiers: z.ZodArray<TIdentifierSchema>;
-}, z.core.$strict>, z.ZodObject<{
-    mode: z.ZodLiteral<"exclude">;
-    excludedIdentifiers: z.ZodArray<TIdentifierSchema>;
-}, z.core.$strict>], "mode">;
-
+declare function zodBulkSelectionSchema<const TIdentifierSchema extends z$1.ZodType<string | number>>({ identifierSchema }: {
+  /**
+   * Schema used to validate every included or excluded entity identifier.
+   * Its transforms and exact inferred output are preserved in both branches.
+   */
+  identifierSchema: TIdentifierSchema;
+}): z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+  mode: z$1.ZodLiteral<"include">;
+  identifiers: z$1.ZodArray<TIdentifierSchema>;
+}, z$1.core.$strict>, z$1.ZodObject<{
+  mode: z$1.ZodLiteral<"exclude">;
+  excludedIdentifiers: z$1.ZodArray<TIdentifierSchema>;
+}, z$1.core.$strict>], "mode">;
+//#endregion
+//#region src/zod-bulk/zod-bulk.types.d.ts
 /**
  * Shared bulk-selection payload produced by `zodBulkSelectionSchema`.
  * String identifiers are used by default for frontend table integrations.
  */
-type ZodBulkSelection<TIdentifier extends string | number = string> = z$1.infer<ReturnType<typeof zodBulkSelectionSchema<z.ZodType<TIdentifier>>>>;
+type ZodBulkSelection<TIdentifier extends string | number = string> = z.infer<ReturnType<typeof zodBulkSelectionSchema<z.ZodType<TIdentifier>>>>;
 /**
  * Explicit bulk selection containing only identifiers chosen by the client.
  * This branch does not require resolving an all-matching search snapshot.
  */
 type ZodBulkIncludeSelection<TIdentifier extends string | number = string> = Extract<ZodBulkSelection<TIdentifier>, {
-    mode: 'include';
+  mode: 'include';
 }>;
 /**
  * All-matching bulk selection containing identifiers excluded by the client.
  * Backend handlers must resolve targets from the same search snapshot.
  */
 type ZodBulkExcludeSelection<TIdentifier extends string | number = string> = Extract<ZodBulkSelection<TIdentifier>, {
-    mode: 'exclude';
+  mode: 'exclude';
 }>;
-
+//#endregion
+//#region src/zod-jwt/zod-jwt.types.d.ts
 /**
  * Configures the algorithm and default expiration used by `ZodJWTService`.
  * Omitted values fall back to `HS256` and fifteen minutes respectively.
  */
 type JWTServiceOptions = {
-    /**
-     * Symmetric algorithm used to sign and verify every token handled by the service.
-     * Defaults to `HS256` when the configuration does not provide another value.
-     */
-    algorithm?: SymmetricAlgorithm;
-    /**
-     * Default lifetime assigned to signed tokens, expressed in seconds.
-     * Defaults to `900` seconds, which is equivalent to fifteen minutes.
-     */
-    defaultExpirationSeconds?: number;
+  /**
+   * Symmetric algorithm used to sign and verify every token handled by the service.
+   * Defaults to `HS256` when the configuration does not provide another value.
+   */
+  algorithm?: SymmetricAlgorithm;
+  /**
+   * Default lifetime assigned to signed tokens, expressed in seconds.
+   * Defaults to `900` seconds, which is equivalent to fifteen minutes.
+   */
+  defaultExpirationSeconds?: number;
 };
 /**
  * Configures one JWT signing operation without changing service defaults.
  * A supplied expiration takes precedence over `defaultExpirationSeconds`.
  */
 type JWTSignOptions = {
-    /**
-     * Lifetime assigned to the token created by this signing operation.
-     * Overrides the service default and remains expressed in seconds.
-     */
-    expiresInSeconds?: number;
+  /**
+   * Lifetime assigned to the token created by this signing operation.
+   * Overrides the service default and remains expressed in seconds.
+   */
+  expiresInSeconds?: number;
 };
 /**
  * Resolves the parsed payload of a Zod schema or preserves a direct payload type.
  * Schema transforms are reflected in the resulting inferred payload.
  */
-type Payload<T> = T extends z$1.ZodType ? z$1.infer<T> : T;
+type Payload<T> = T extends z.ZodType ? z.infer<T> : T;
 /**
  * Preserves a Zod payload schema and rejects direct payload types with `never`.
  * The result controls whether runtime payload validation is available.
  */
-type PayloadSchema<T> = T extends z$1.ZodType ? T : never;
-
+type PayloadSchema<T> = T extends z.ZodType ? T : never;
+//#endregion
+//#region src/zod-jwt/zod-jwt.services.d.ts
 /**
  * Signs, decodes, and verifies JWTs with optional Zod payload validation.
  * A supplied schema parses payloads returned by decoding and verification.
  */
 declare class ZodJWTService<TPayloadOrSchema> {
-    readonly payloadSchema: PayloadSchema<TPayloadOrSchema> | undefined;
-    protected readonly algorithm: SymmetricAlgorithm;
-    protected readonly defaultExpirationSeconds: number;
-    constructor(payloadSchema?: PayloadSchema<TPayloadOrSchema>, options?: JWTServiceOptions);
-    /**
-     * Signs a payload using the configured algorithm and expiration settings.
-     * Per-call expiration overrides the default configured by the service.
-     *
-     * @example
-     * const token = await jwtService.sign({ userId: '123' }, secret, { expiresInSeconds: 300 });
-     */
-    sign(payload: Payload<TPayloadOrSchema>, secret: string, options?: JWTSignOptions): Promise<string>;
-    /**
-     * Decodes without authenticating it and parses its payload when a schema exists.
-     * Schema validation failures return `null`, while malformed tokens still reject.
-     *
-     * @example
-     * const payload = await jwtService.decode(token);
-     */
-    decode(token: string): Promise<Payload<TPayloadOrSchema> | null>;
-    /**
-     * Verifies a token using the configured algorithm and parses its payload.
-     * Signature, expiration, and schema validation failures reject the operation.
-     *
-     * @example
-     * const payload = await jwtService.verifyOrThrow(token, secret);
-     */
-    verifyOrThrow(token: string, secret: string): Promise<Payload<TPayloadOrSchema>>;
+  readonly payloadSchema: PayloadSchema<TPayloadOrSchema> | undefined;
+  protected readonly algorithm: SymmetricAlgorithm;
+  protected readonly defaultExpirationSeconds: number;
+  constructor(payloadSchema?: PayloadSchema<TPayloadOrSchema>, options?: JWTServiceOptions);
+  /**
+   * Signs a payload using the configured algorithm and expiration settings.
+   * Per-call expiration overrides the default configured by the service.
+   *
+   * @example
+   * const token = await jwtService.sign({ userId: '123' }, secret, { expiresInSeconds: 300 });
+   */
+  sign(payload: Payload<TPayloadOrSchema>, secret: string, options?: JWTSignOptions): Promise<string>;
+  /**
+   * Decodes without authenticating it and parses its payload when a schema exists.
+   * Schema validation failures return `null`, while malformed tokens still reject.
+   *
+   * @example
+   * const payload = await jwtService.decode(token);
+   */
+  decode(token: string): Promise<Payload<TPayloadOrSchema> | null>;
+  /**
+   * Verifies a token using the configured algorithm and parses its payload.
+   * Signature, expiration, and schema validation failures reject the operation.
+   *
+   * @example
+   * const payload = await jwtService.verifyOrThrow(token, secret);
+   */
+  verifyOrThrow(token: string, secret: string): Promise<Payload<TPayloadOrSchema>>;
 }
-
+//#endregion
+//#region src/zod-search/zod-search.pagination.schemas.d.ts
 /**
  * Validates offset-based pagination shared by search request contracts.
  * Missing fields inside the required object receive predictable defaults.
  */
-declare const zodPaginationSchema: z.ZodObject<{
-    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strip>;
+declare const zodPaginationSchema: z$1.ZodObject<{
+  offset: z$1.ZodDefault<z$1.ZodCoercedNumber<unknown>>;
+  limit: z$1.ZodDefault<z$1.ZodCoercedNumber<unknown>>;
+}, z$1.core.$strip>;
 /**
  * Exposes pagination fields for composition into other object schemas.
  * The shape stays derived from the schema to prevent contract divergence.
  */
 declare const zodPaginationShape: {
-    offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+  offset: z$1.ZodDefault<z$1.ZodCoercedNumber<unknown>>;
+  limit: z$1.ZodDefault<z$1.ZodCoercedNumber<unknown>>;
 };
-
+//#endregion
+//#region src/zod-search/zod-search.types.d.ts
 /**
  * TypeScript output produced after successful pagination validation.
  * Defaulted fields are represented as required numeric properties.
  */
-type ZodPaginationOptions = z$1.infer<typeof zodPaginationSchema>;
+type ZodPaginationOptions = z.infer<typeof zodPaginationSchema>;
 /**
  * Feature flags shared by both supported search schema composition modes.
  * Literal values are preserved in the resulting runtime and static shapes.
  */
 type ZodSearchFeatureOptions<TQueryEnabled extends boolean, TPaginationEnabled extends boolean> = {
-    /**
-     * Controls whether an optional non-empty `query` field is generated.
-     * The field is enabled when this option is omitted from the call.
-     */
-    queryEnabled?: TQueryEnabled;
-    /**
-     * Controls whether a required `pagination` object is generated.
-     * The field is enabled when this option is omitted from the call.
-     */
-    paginationEnabled?: TPaginationEnabled;
+  /**
+   * Controls whether an optional non-empty `query` field is generated.
+   * The field is enabled when this option is omitted from the call.
+   */
+  queryEnabled?: TQueryEnabled;
+  /**
+   * Controls whether a required `pagination` object is generated.
+   * The field is enabled when this option is omitted from the call.
+   */
+  paginationEnabled?: TPaginationEnabled;
 };
 /**
  * Configuration used to compose a reusable search request schema.
@@ -896,34 +929,35 @@ type ZodSearchFeatureOptions<TQueryEnabled extends boolean, TPaginationEnabled e
  * `filters` is the concise mode that applies partial and non-empty rules.
  * `whereSchema` accepts a fully prepared schema with custom Zod effects.
  */
-type ZodSearchSchemaOptions<TShape extends z$1.ZodRawShape = never, TWhereSchema extends z$1.ZodType<Record<string, unknown>> = never, TQueryEnabled extends boolean = true, TPaginationEnabled extends boolean = true> = ZodSearchFeatureOptions<TQueryEnabled, TPaginationEnabled> & ({
-    /**
-     * Object schema whose fields become optional filters inside `where`.
-     * The factory requires one defined value whenever `where` is present.
-     */
-    filters: z$1.ZodObject<TShape>;
-    /** Prevents combining automatic filters with a prepared schema. */
-    whereSchema?: never;
+type ZodSearchSchemaOptions<TShape extends z.ZodRawShape = never, TWhereSchema extends z.ZodType<Record<string, unknown>> = never, TQueryEnabled extends boolean = true, TPaginationEnabled extends boolean = true> = ZodSearchFeatureOptions<TQueryEnabled, TPaginationEnabled> & ({
+  /**
+   * Object schema whose fields become optional filters inside `where`.
+   * The factory requires one defined value whenever `where` is present.
+   */
+  filters: z.ZodObject<TShape>;
+  /** Prevents combining automatic filters with a prepared schema. */
+  whereSchema?: never;
 } | {
-    /** Prevents combining a prepared schema with automatic filters. */
-    filters?: never;
-    /**
-     * Prepared schema used directly to validate the `where` object.
-     * Its refinements, transforms, and inferred output are preserved.
-     */
-    whereSchema: TWhereSchema;
+  /** Prevents combining a prepared schema with automatic filters. */
+  filters?: never;
+  /**
+   * Prepared schema used directly to validate the `where` object.
+   * Its refinements, transforms, and inferred output are preserved.
+   */
+  whereSchema: TWhereSchema;
 });
-
+//#endregion
+//#region src/zod-search/zod-search.schemas.d.ts
 /**
  * Optional text query shared by search request contracts.
  * Provided values are trimmed and must contain visible text.
  */
-declare const zodSearchQuerySchema: z.ZodOptional<z.ZodString>;
+declare const zodSearchQuerySchema: z$1.ZodOptional<z$1.ZodString>;
 /**
  * Makes every supplied filter optional while requiring one defined value.
  * Top-level optionality is added later for both composition modes equally.
  */
-declare const createZodSearchWhereSchema: <TShape extends z.ZodRawShape>(filters: z.ZodObject<TShape>) => z.ZodPipe<z.ZodObject<{ -readonly [k in keyof TShape]: z.ZodOptional<TShape[k]>; }, z.core.$strip>, z.ZodTransform<Awaited<AtLeastOne<z.core.$InferObjectOutput<{ -readonly [k in keyof TShape]: z.ZodOptional<TShape[k]>; }, {}>, keyof z.core.$InferObjectOutput<{ -readonly [k in keyof TShape]: z.ZodOptional<TShape[k]>; }, {}>>>, z.core.$InferObjectOutput<{ -readonly [k in keyof TShape]: z.ZodOptional<TShape[k]>; }, {}>>>;
+declare const createZodSearchWhereSchema: <TShape extends z$1.ZodRawShape>(filters: z$1.ZodObject<TShape>) => z$1.ZodPipe<z$1.ZodObject<{ -readonly [k in keyof TShape]: z$1.ZodOptional<TShape[k]>; }, z$1.core.$strip>, z$1.ZodTransform<Awaited<AtLeastOne<z$1.core.$InferObjectOutput<{ -readonly [k in keyof TShape]: z$1.ZodOptional<TShape[k]>; }, {}>, keyof z$1.core.$InferObjectOutput<{ -readonly [k in keyof TShape]: z$1.ZodOptional<TShape[k]>; }, {}>>>, z$1.core.$InferObjectOutput<{ -readonly [k in keyof TShape]: z$1.ZodOptional<TShape[k]>; }, {}>>>;
 /**
  * Empty schema shape used when a search feature is explicitly disabled.
  * Intersections remove disabled fields without widening enabled branches.
@@ -933,19 +967,17 @@ type ZodDisabledSearchShape = Record<never, never>;
  * Resolves the schema used by `where` from the selected composition mode.
  * Prepared schemas remain untouched, including their effects and output.
  */
-type ZodSearchWhereSchema<TShape extends z.ZodRawShape, TWhereSchema extends z.ZodType<Record<string, unknown>>> = [
-    TWhereSchema
-] extends [never] ? ReturnType<typeof createZodSearchWhereSchema<TShape>> : TWhereSchema;
+type ZodSearchWhereSchema<TShape extends z$1.ZodRawShape, TWhereSchema extends z$1.ZodType<Record<string, unknown>>> = [TWhereSchema] extends [never] ? ReturnType<typeof createZodSearchWhereSchema<TShape>> : TWhereSchema;
 /**
  * Schema-level shape assembled from the selected source and feature flags.
  * Keeping Zod schemas here makes runtime composition the contract source.
  */
-type ZodSearchShape<TShape extends z.ZodRawShape, TWhereSchema extends z.ZodType<Record<string, unknown>>, TQueryEnabled extends boolean, TPaginationEnabled extends boolean> = {
-    where: z.ZodOptional<ZodSearchWhereSchema<TShape, TWhereSchema>>;
+type ZodSearchShape<TShape extends z$1.ZodRawShape, TWhereSchema extends z$1.ZodType<Record<string, unknown>>, TQueryEnabled extends boolean, TPaginationEnabled extends boolean> = {
+  where: z$1.ZodOptional<ZodSearchWhereSchema<TShape, TWhereSchema>>;
 } & (TQueryEnabled extends false ? ZodDisabledSearchShape : {
-    query: typeof zodSearchQuerySchema;
+  query: typeof zodSearchQuerySchema;
 }) & (TPaginationEnabled extends false ? ZodDisabledSearchShape : {
-    pagination: typeof zodPaginationSchema;
+  pagination: typeof zodPaginationSchema;
 });
 /**
  * Builds a strict schema for reusable search request contracts.
@@ -966,16 +998,15 @@ type ZodSearchShape<TShape extends z.ZodRawShape, TWhereSchema extends z.ZodType
  *   whereSchema: zodAtLeastOne(assetSchema.pick({ status: true }).partial()),
  * });
  */
-declare const zodSearchSchema: <const TShape extends z.ZodRawShape = never, const TWhereSchema extends z.ZodType<Record<string, unknown>> = never, const TQueryEnabled extends boolean = true, const TPaginationEnabled extends boolean = true>(options: ZodSearchSchemaOptions<TShape, TWhereSchema, TQueryEnabled, TPaginationEnabled>) => z.ZodObject<ZodSearchShape<TShape, TWhereSchema, TQueryEnabled, TPaginationEnabled> extends infer T ? { -readonly [P in keyof T]: T[P]; } : never, z.core.$strict>;
-
+declare const zodSearchSchema: <const TShape extends z$1.ZodRawShape = never, const TWhereSchema extends z$1.ZodType<Record<string, unknown>> = never, const TQueryEnabled extends boolean = true, const TPaginationEnabled extends boolean = true>(options: ZodSearchSchemaOptions<TShape, TWhereSchema, TQueryEnabled, TPaginationEnabled>) => z$1.ZodObject<ZodSearchShape<TShape, TWhereSchema, TQueryEnabled, TPaginationEnabled> extends (infer T) ? { -readonly [P in keyof T]: T[P]; } : never, z$1.core.$strict>;
+//#endregion
+//#region src/zod-validation/zod-validation.types.d.ts
 type StringifiablePayloadValue = string | number | boolean | bigint | Date;
 /**
  * Recursively transforms payload values to strings while preserving container structure.
  * Nullable and omitted members remain unchanged for transport-layer omission handling.
  */
-type StringifiedPayload<TValue> = TValue extends null | undefined ? TValue : TValue extends StringifiablePayloadValue ? string : TValue extends readonly (infer TItem)[] ? StringifiedPayload<TItem>[] : TValue extends object ? {
-    [TKey in keyof TValue]: StringifiedPayload<TValue[TKey]>;
-} : string;
+type StringifiedPayload<TValue> = TValue extends null | undefined ? TValue : TValue extends StringifiablePayloadValue ? string : TValue extends readonly (infer TItem)[] ? StringifiedPayload<TItem>[] : TValue extends object ? { [TKey in keyof TValue]: StringifiedPayload<TValue[TKey]>; } : string;
 /**
  * Utility type that ensures at least one property from the specified
  * keys of a given type T is required, while the rest remain optional.
@@ -989,7 +1020,8 @@ type StringifiedPayload<TValue> = TValue extends null | undefined ? TValue : TVa
  * // Invalid: {}, { a: undefined, b: undefined, c: undefined }
  */
 type AtLeastOne<T, Keys extends keyof T = keyof T> = Keys extends keyof T ? Simplify<Required<Pick<T, Keys>> & Partial<Omit<T, Keys>>> : never;
-
+//#endregion
+//#region src/zod-validation/zod-validation.refiners.d.ts
 /**
  * Wraps a partial Zod object schema with:
  * 1. A runtime check ensuring at least one field is non-undefined.
@@ -999,8 +1031,9 @@ type AtLeastOne<T, Keys extends keyof T = keyof T> = Keys extends keyof T ? Simp
  * @example
  * zQuery(zodAtLeastOne(userSelectSchema)) // result: UserSelect ✓
  */
-declare const zodAtLeastOne: <T extends ZodObject<ZodRawShape>>(schema: T) => z.ZodPipe<T, z.ZodTransform<Awaited<AtLeastOne<z.core.output<T>>>, z.core.output<T>>>;
-
+declare const zodAtLeastOne: <T extends ZodObject<ZodRawShape>>(schema: T) => z$1.ZodPipe<T, z$1.ZodTransform<Awaited<AtLeastOne<z$1.TypeOf<T>>>, z$1.TypeOf<T>>>;
+//#endregion
+//#region src/zod-validation/zod-validation.parsing.d.ts
 declare const parseQueryValue: (value: unknown) => unknown;
 /**
  * Preprocesses query-like values before Zod validation.
@@ -1018,7 +1051,7 @@ declare const parseQueryValue: (value: unknown) => unknown;
  * schema.parse({ page: '2', isActive: 'true' });
  * // { page: 2, isActive: true }
  */
-declare const asQuery: <T extends z.ZodTypeAny>(schema: T) => z.ZodPreprocess<T>;
+declare const asQuery: <T extends z$1.ZodTypeAny>(schema: T) => z$1.ZodPreprocess<T>;
 /**
  * Recursively converts payload values to strings without changing container structure.
  * Objects and arrays are copied while `null` and `undefined` retain omission semantics.
@@ -1028,11 +1061,12 @@ declare const asQuery: <T extends z.ZodTypeAny>(schema: T) => z.ZodPreprocess<T>
  * // { page: '2', enabled: 'true' }
  */
 declare function stringifyPayloadValues<TValue>(value: TValue): StringifiedPayload<TValue>;
-
+//#endregion
+//#region src/zod-validation/zod-validation.utilities.d.ts
 /**
  * Checks whether a value is a plain record backed by `Object.prototype`.
  * Arrays, null, dates, collections, and custom class instances are rejected.
  */
 declare const isPlainObject: (value: unknown) => value is Record<string, unknown>;
-
-export { type APIContractData, type APIContractError, type APIContractResult, type APIError, type APISuccess, type AtLeastOne, DEFAULT_HMAC_ALGORITHM, DEFAULT_HMAC_ENCODING, DEFAULT_UPLOAD_MAX_FILE_SIZE, EXCEPTION_STATUS_CODES, type ExceptionStatusCode, type FetchResult, type FileFormat, type FileFormatConfig, type HMACAlgorithm, type HMACEncoding, type HMACInput, HMACService, type HMACServiceOptions, type HonoFileRespondOptions, type HonoRespondOptions, type JWTServiceOptions, type JWTSignOptions, type LogLevel, type MeasuredExecution, type Payload, type PayloadSchema, REDACTED_LOG_VALUE, type ReplaceDotsWithUnderscores, type ReplaceHyphensWithUnderscores, SUCCESS_STATUS_CODES, type Simplify, type StringEnumRecord, type StringifiedPayload, type SuccessStatusCode, type UploadFilesValidationOptions, type UploadFilesValidationResult, type UploadPreset, type UploadValidationError, type ZodBulkExcludeSelection, type ZodBulkIncludeSelection, type ZodBulkSelection, ZodJWTService, type ZodPaginationOptions, type ZodSearchSchemaOptions, type ZodUploadFileSchemaOptions, asQuery, createStringEnumRecord, createUploadAccept, createZodSearchWhereSchema, decodeBase64, decodeHMACSignature, defineUploadPreset, documentUploadPreset, encodeBase64, encodeHMACSignature, failure, fetchAndThrow, fetchSafely, fileFormat, fileFormatsArray, fileFormatsConfig, fileFormatsRecord, fileRespond, formatTime, generateRandomString, getColoredHTTPStatus, getFileExtension, getFormattedDate, getFormattedTime, getUTCOffset, getZonedTime, hmacAlgorithm, hmacAlgorithmsArray, hmacAlgorithmsRecord, hmacEncoding, hmacEncodingsArray, hmacEncodingsRecord, httpStatusColors, imageTransparentUploadPreset, imageUploadPreset, isFileExtensionSupported, isFileFormatSupported, isFileMimeTypeSupported, isPlainObject, log, logLevel, logLevelColors, logLevelsArray, logLevelsRecord, loggingMiddleware, matchesMimeType, measureExecutionTime, normalizeFileExtension, onHandlerError, parseQueryValue, redactSensitiveJSON, redactSensitiveSearchParams, respond, safeExecute, sensitiveLogKeyParts, sqlWhere, stringifyPayloadValues, success, toHMACBytes, uploadValidationError, uploadValidationErrorsArray, uploadValidationErrorsRecord, validateUploadFile, validateUploadFiles, zodAtLeastOne, zodBulkSelectionSchema, zodPaginationSchema, zodPaginationShape, zodSearchQuerySchema, zodSearchSchema, zodUploadFileSchema };
+//#endregion
+export { APIContractData, APIContractError, APIContractResult, APIError, APISuccess, AtLeastOne, DEFAULT_HMAC_ALGORITHM, DEFAULT_HMAC_ENCODING, DEFAULT_UPLOAD_MAX_FILE_SIZE, EXCEPTION_STATUS_CODES, ExceptionStatusCode, FetchResult, FileFormat, FileFormatConfig, HMACAlgorithm, HMACEncoding, HMACInput, HMACService, HMACServiceOptions, HonoFileRespondOptions, HonoRespondOptions, JWTServiceOptions, JWTSignOptions, LogLevel, MeasuredExecution, Payload, PayloadSchema, REDACTED_LOG_VALUE, ReplaceDotsWithUnderscores, ReplaceHyphensWithUnderscores, SUCCESS_STATUS_CODES, Simplify, StringEnumRecord, StringifiedPayload, SuccessStatusCode, UploadFilesValidationOptions, UploadFilesValidationResult, UploadPreset, UploadValidationError, ZodBulkExcludeSelection, ZodBulkIncludeSelection, ZodBulkSelection, ZodJWTService, ZodPaginationOptions, ZodSearchSchemaOptions, ZodUploadFileSchemaOptions, asQuery, createStringEnumRecord, createUploadAccept, createZodSearchWhereSchema, decodeBase64, decodeHMACSignature, defineUploadPreset, documentUploadPreset, encodeBase64, encodeHMACSignature, failure, fetchAndThrow, fetchSafely, fileFormat, fileFormatsArray, fileFormatsConfig, fileFormatsRecord, fileRespond, formatTime, generateRandomString, getColoredHTTPStatus, getFileExtension, getFormattedDate, getFormattedTime, getUTCOffset, getZonedTime, hmacAlgorithm, hmacAlgorithmsArray, hmacAlgorithmsRecord, hmacEncoding, hmacEncodingsArray, hmacEncodingsRecord, httpStatusColors, imageTransparentUploadPreset, imageUploadPreset, isFileExtensionSupported, isFileFormatSupported, isFileMimeTypeSupported, isPlainObject, log, logLevel, logLevelColors, logLevelsArray, logLevelsRecord, loggingMiddleware, matchesMimeType, measureExecutionTime, normalizeFileExtension, onHandlerError, parseQueryValue, redactSensitiveJSON, redactSensitiveSearchParams, respond, safeExecute, sensitiveLogKeyParts, sqlWhere, stringifyPayloadValues, success, toHMACBytes, uploadValidationError, uploadValidationErrorsArray, uploadValidationErrorsRecord, validateUploadFile, validateUploadFiles, zodAtLeastOne, zodBulkSelectionSchema, zodPaginationSchema, zodPaginationShape, zodSearchQuerySchema, zodSearchSchema, zodUploadFileSchema };