@gzl10/ts-helpers 4.2.1

package/dist/types/environment-B8eLS7KT.d.ts

@@ -0,0 +1,420 @@
+/**
+ * Environment detection utilities for universal browser/Node.js compatibility
+ */
+/**
+ * Detailed criteria used for environment debugging and analysis
+ */
+interface EnvironmentCriteria {
+    /** True if hostname is localhost, 127.0.0.1, ::1, or .localhost/.local domain */
+    isLocalhost: boolean;
+    /** True if hostname is within private IP ranges (10.x, 192.168.x, 172.16-31.x) */
+    isPrivateIP: boolean;
+    /** True if port is in development range (3000-9999) */
+    isDevelopmentPort: boolean;
+    /** True if development tools are detected (Vue DevTools, __DEV__ global) */
+    hasDevtools: boolean;
+    /** Current NODE_ENV value (Node.js only) */
+    nodeEnv?: string;
+}
+/**
+ * Complete environment information with platform detection and debugging criteria
+ */
+interface EnvironmentInfo {
+    /** Runtime platform: 'browser', 'node', or 'unknown' */
+    platform: 'browser' | 'node' | 'unknown';
+    /** Detected environment: 'development', 'production', or 'test' */
+    environment: 'development' | 'production' | 'test';
+    /** Protocol used (http/https) - from location or request headers */
+    protocol?: string;
+    /** Hostname - from location or request headers */
+    hostname?: string;
+    /** Browser user agent string (browser only) */
+    userAgent?: string;
+    /** Detailed debugging criteria */
+    criteria?: EnvironmentCriteria;
+}
+/**
+ * Detects if the current runtime is Node.js environment
+ *
+ * Checks for the presence of Node.js-specific globals (process, process.versions.node)
+ * and absence of browser globals (window).
+ *
+ * @returns True if running in Node.js, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isNodeEnvironment()) {
+ *   // Node.js specific code
+ *   const fs = require('fs')
+ * }
+ * ```
+ */
+declare function isNodeEnvironment(): boolean;
+/**
+ * Detects if the current runtime is a browser environment
+ *
+ * Checks for the presence of browser-specific globals (window, document).
+ * Also handles testing environments that may mock these globals.
+ *
+ * @returns True if running in browser, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isBrowserEnvironment()) {
+ *   // Browser specific code
+ *   const url = window.location.href
+ * }
+ * ```
+ */
+declare function isBrowserEnvironment(): boolean;
+/**
+ * Detects if the application is running in development mode
+ *
+ * Uses sophisticated detection logic based on multiple criteria:
+ * - Node.js: NODE_ENV variable, request headers (for Express), hostname/protocol analysis
+ * - Browser: __DEV__ global, development ports (3000-9999), localhost/private IPs, dev tools
+ *
+ * Handles reverse proxies correctly by checking forwarded headers.
+ *
+ * @param req - Optional Express request object for server-side detection
+ * @returns True if in development mode, false if production
+ *
+ * @example
+ * ```typescript
+ * // Node.js - simple check
+ * if (isDevelopment()) {
+ *   console.log('Development mode')
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Express - with request context
+ * app.get('/api/status', (req, res) => {
+ *   const isDev = isDevelopment(req)
+ *   res.json({ environment: isDev ? 'dev' : 'prod' })
+ * })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Browser - automatic detection
+ * if (isDevelopment()) {
+ *   // Enable debug logging, dev tools, etc.
+ *   enableDebugMode()
+ * }
+ * ```
+ */
+declare function isDevelopment(req?: any): boolean;
+/**
+ * Detects if the application is running in production mode
+ *
+ * Simple inverse of isDevelopment() with additional NODE_ENV validation for Node.js.
+ *
+ * @returns True if in production mode, false if development
+ *
+ * @example
+ * ```typescript
+ * if (isProduction()) {
+ *   // Enable performance optimizations
+ *   enableProductionMode()
+ * }
+ * ```
+ */
+declare function isProduction(): boolean;
+/**
+ * Detects if the application is running in test mode
+ *
+ * Checks explicitly for NODE_ENV === 'test' in Node.js environments.
+ * Vitest and Jest automatically set this value when running tests.
+ *
+ * @returns True if NODE_ENV is 'test', false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isTest()) {
+ *   // Test-specific behavior (mocks, fixtures, etc.)
+ *   enableTestMode()
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Conditional imports for testing
+ * if (isTest()) {
+ *   const { mockAPI } = await import('./test/mocks')
+ *   mockAPI.setup()
+ * }
+ * ```
+ */
+declare function isTest(): boolean;
+/**
+ * Detects if the application is NOT running in production mode
+ *
+ * Returns true for development, test, undefined, or any non-production environment.
+ * Useful for enabling debugging, logging, or development-only features
+ * across all non-production environments.
+ *
+ * @returns True if not in production (development, test, or undefined)
+ *
+ * @example
+ * ```typescript
+ * if (isNonProduction()) {
+ *   // Enable debug logging for dev and test
+ *   console.log('Debug mode enabled')
+ *   enableVerboseLogging()
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Security: Disable strict checks in non-production
+ * if (isNonProduction()) {
+ *   allowSelfSignedCertificates()
+ *   disableCSRFProtection()
+ * }
+ * ```
+ */
+declare function isNonProduction(): boolean;
+/**
+ * Detects the protocol (HTTP/HTTPS) from browser location or request headers
+ *
+ * Handles reverse proxies correctly by checking forwarded headers in priority order:
+ * 1. X-Forwarded-Proto (most common)
+ * 2. X-Forwarded-Protocol
+ * 3. X-Url-Scheme
+ * 4. Front-End-Https
+ * 5. CF-Visitor (Cloudflare specific)
+ *
+ * @param req - Optional Express request object with headers
+ * @returns Protocol as 'http' or 'https'
+ *
+ * @example
+ * ```typescript
+ * // Browser usage
+ * const protocol = detectProtocol() // 'https' from window.location
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Express server with proxy
+ * app.get('/api', (req, res) => {
+ *   const protocol = detectProtocol(req) // Detects from X-Forwarded-Proto
+ *   const fullUrl = `${protocol}://${req.get('host')}${req.path}`
+ * })
+ * ```
+ */
+declare function detectProtocol(req?: any): 'http' | 'https';
+/**
+ * Extracts hostname from browser location or request headers
+ *
+ * Handles reverse proxies by checking forwarded headers in priority order:
+ * 1. X-Forwarded-Host (most common, supports multiple hosts)
+ * 2. X-Original-Host
+ * 3. Host header
+ *
+ * Automatically strips port numbers and handles multiple comma-separated hosts.
+ *
+ * @param req - Optional Express request object with headers
+ * @returns Hostname without port number
+ *
+ * @example
+ * ```typescript
+ * // Browser usage
+ * const hostname = detectHostname() // 'example.com' from window.location
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Express server behind proxy
+ * app.get('/api', (req, res) => {
+ *   const hostname = detectHostname(req) // 'api.example.com' from X-Forwarded-Host
+ *   const isLocal = isLocalhost(hostname)
+ * })
+ * ```
+ */
+declare function detectHostname(req?: any): string;
+/**
+ * Checks if a hostname represents localhost or local development
+ *
+ * Recognizes various localhost representations:
+ * - 'localhost' (standard)
+ * - '127.0.0.1' (IPv4 loopback)
+ * - '::1' (IPv6 loopback)
+ * - '*.localhost' (local development domains)
+ * - '*.local' (mDNS local domains)
+ *
+ * @param hostname - Hostname to check
+ * @returns True if hostname represents localhost
+ *
+ * @example
+ * ```typescript
+ * isLocalhost('localhost')        // true
+ * isLocalhost('127.0.0.1')        // true
+ * isLocalhost('app.localhost')    // true
+ * isLocalhost('macbook.local')    // true
+ * isLocalhost('example.com')      // false
+ * ```
+ */
+declare function isLocalhost(hostname: string): boolean;
+/**
+ * Checks if a hostname is within private IP address ranges
+ *
+ * Recognizes private/internal IP ranges according to RFC 1918:
+ * - IPv4: 10.x.x.x, 192.168.x.x, 172.16-31.x.x, 127.x.x.x (loopback)
+ * - IPv6: ::1 (loopback), fc00::/7 (unique local), fe80::/10 (link-local)
+ * - Also includes localhost detection
+ *
+ * @param hostname - Hostname or IP address to check
+ * @returns True if hostname is private/local, false if public
+ *
+ * @example
+ * ```typescript
+ * isPrivateIP('192.168.1.1')      // true
+ * isPrivateIP('10.0.0.1')         // true
+ * isPrivateIP('172.16.0.1')       // true
+ * isPrivateIP('localhost')        // true
+ * isPrivateIP('8.8.8.8')          // false
+ * isPrivateIP('example.com')      // false
+ * ```
+ */
+declare function isPrivateIP(hostname: string): boolean;
+/**
+ * Gathers complete environment information for debugging and analysis
+ *
+ * Returns comprehensive environment data including platform detection,
+ * development/production status, protocol/hostname information, and
+ * detailed debugging criteria.
+ *
+ * @param req - Optional Express request object for server-side context
+ * @returns Complete environment information object
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const env = getEnvironmentInfo()
+ * console.log(env.platform)     // 'node' | 'browser' | 'unknown'
+ * console.log(env.environment)  // 'development' | 'production' | 'test'
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Express server usage
+ * app.get('/api/debug', (req, res) => {
+ *   const envInfo = getEnvironmentInfo(req)
+ *   res.json({
+ *     platform: envInfo.platform,
+ *     isDev: envInfo.environment === 'development',
+ *     protocol: envInfo.protocol,
+ *     host: envInfo.hostname,
+ *     criteria: envInfo.criteria
+ *   })
+ * })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Conditional features based on environment
+ * const env = getEnvironmentInfo()
+ * if (env.criteria?.hasDevtools) {
+ *   enableVueDevtools()
+ * }
+ * if (env.criteria?.isDevelopmentPort) {
+ *   enableHotReload()
+ * }
+ * ```
+ */
+declare function getEnvironmentInfo(req?: any): EnvironmentInfo;
+/**
+ * Alias for isNodeEnvironment() - detects Node.js runtime
+ * @see {@link isNodeEnvironment}
+ */
+declare const isNode: typeof isNodeEnvironment;
+/**
+ * Alias for isBrowserEnvironment() - detects browser runtime
+ * @see {@link isBrowserEnvironment}
+ */
+declare const isBrowser: typeof isBrowserEnvironment;
+/**
+ * Parses environment variable string values to their native JavaScript types
+ *
+ * Automatically detects and converts:
+ * - Booleans: 'true', 'false', 'yes', 'no', '1', '0'
+ * - Numbers: '42', '3.14', '-100'
+ * - JSON arrays: '[1,2,3]', '["a","b"]'
+ * - JSON objects: '{"key":"value"}'
+ * - Comma-separated arrays: 'item1,item2,item3' (when not valid JSON)
+ * - null/undefined: 'null', 'undefined', empty string
+ *
+ * Falls back to original string if no conversion applies.
+ *
+ * @param value - Environment variable string value to parse
+ * @returns Parsed value with appropriate native type
+ *
+ * @example
+ * ```typescript
+ * // Boolean conversion
+ * parseEnvValue('true')      // true
+ * parseEnvValue('false')     // false
+ * parseEnvValue('yes')       // true
+ * parseEnvValue('1')         // true (as boolean)
+ *
+ * // Number conversion
+ * parseEnvValue('42')        // 42
+ * parseEnvValue('3.14')      // 3.14
+ * parseEnvValue('-100')      // -100
+ *
+ * // JSON arrays
+ * parseEnvValue('[1,2,3]')   // [1, 2, 3]
+ * parseEnvValue('["a","b"]') // ['a', 'b']
+ *
+ * // JSON objects
+ * parseEnvValue('{"port":3000,"host":"localhost"}')
+ * // { port: 3000, host: 'localhost' }
+ *
+ * // Comma-separated arrays (fallback when not JSON)
+ * parseEnvValue('red,green,blue')  // ['red', 'green', 'blue']
+ *
+ * // Null/undefined
+ * parseEnvValue('null')      // null
+ * parseEnvValue('undefined') // undefined
+ * parseEnvValue('')          // undefined
+ *
+ * // Strings (no conversion)
+ * parseEnvValue('hello')     // 'hello'
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Real-world usage with process.env
+ * const config = {
+ *   debug: parseEnvValue(process.env.DEBUG),           // 'true' → true
+ *   port: parseEnvValue(process.env.PORT),             // '3000' → 3000
+ *   features: parseEnvValue(process.env.FEATURES),     // 'auth,api' → ['auth', 'api']
+ *   database: parseEnvValue(process.env.DB_CONFIG),    // '{"host":"localhost"}' → object
+ * }
+ * ```
+ */
+declare function parseEnvValue(value: string | undefined): any;
+
+type environment_EnvironmentCriteria = EnvironmentCriteria;
+type environment_EnvironmentInfo = EnvironmentInfo;
+declare const environment_detectHostname: typeof detectHostname;
+declare const environment_detectProtocol: typeof detectProtocol;
+declare const environment_getEnvironmentInfo: typeof getEnvironmentInfo;
+declare const environment_isBrowser: typeof isBrowser;
+declare const environment_isBrowserEnvironment: typeof isBrowserEnvironment;
+declare const environment_isDevelopment: typeof isDevelopment;
+declare const environment_isLocalhost: typeof isLocalhost;
+declare const environment_isNode: typeof isNode;
+declare const environment_isNodeEnvironment: typeof isNodeEnvironment;
+declare const environment_isNonProduction: typeof isNonProduction;
+declare const environment_isPrivateIP: typeof isPrivateIP;
+declare const environment_isProduction: typeof isProduction;
+declare const environment_isTest: typeof isTest;
+declare const environment_parseEnvValue: typeof parseEnvValue;
+declare namespace environment {
+  export { type environment_EnvironmentCriteria as EnvironmentCriteria, type environment_EnvironmentInfo as EnvironmentInfo, environment_detectHostname as detectHostname, environment_detectProtocol as detectProtocol, environment_getEnvironmentInfo as getEnvironmentInfo, environment_isBrowser as isBrowser, environment_isBrowserEnvironment as isBrowserEnvironment, environment_isDevelopment as isDevelopment, environment_isLocalhost as isLocalhost, environment_isNode as isNode, environment_isNodeEnvironment as isNodeEnvironment, environment_isNonProduction as isNonProduction, environment_isPrivateIP as isPrivateIP, environment_isProduction as isProduction, environment_isTest as isTest, environment_parseEnvValue as parseEnvValue };
+}
+
+export { type EnvironmentInfo as E, isNodeEnvironment as a, type EnvironmentCriteria as b, isDevelopment as c, isProduction as d, environment as e, isTest as f, isNonProduction as g, detectProtocol as h, isBrowserEnvironment as i, detectHostname as j, isLocalhost as k, isPrivateIP as l, getEnvironmentInfo as m, isNode as n, isBrowser as o, parseEnvValue as p };

package/dist/types/environment-detection.d.ts

@@ -0,0 +1,102 @@
+import { i as isBrowserEnvironment, a as isNodeEnvironment } from './environment-B8eLS7KT.js';
+
+/**
+ * Universal crypto capabilities detection utilities
+ * Safe for all environments with comprehensive fallbacks
+ */
+
+/**
+ * Enhanced browser environment detection with additional checks
+ * @returns true if running in a browser environment
+ * @example
+ * ```ts
+ * if (isBrowserEnv()) {
+ *   console.log('Running in browser')
+ * }
+ * ```
+ */
+declare const isBrowserEnv: typeof isBrowserEnvironment;
+/**
+ * Enhanced Node.js environment detection with additional checks
+ * @returns true if running in Node.js environment
+ * @example
+ * ```ts
+ * if (isNodeEnv()) {
+ *   console.log('Running in Node.js')
+ * }
+ * ```
+ */
+declare const isNodeEnv: typeof isNodeEnvironment;
+/**
+ * Detects if running in Worker environment (Web Workers, Service Workers)
+ * @returns true if running in a Worker context
+ * @example
+ * ```ts
+ * if (isWorkerEnvironment()) {
+ *   console.log('Running in Web Worker')
+ * }
+ * ```
+ */
+declare const isWorkerEnvironment: () => boolean;
+/**
+ * Detects if Web Crypto API is available in the current environment
+ * @returns true if crypto.getRandomValues and crypto.subtle are available
+ * @example
+ * ```ts
+ * if (isWebCryptoAvailable()) {
+ *   const array = new Uint8Array(16)
+ *   crypto.getRandomValues(array)
+ * }
+ * ```
+ */
+declare const isWebCryptoAvailable: () => boolean;
+/**
+ * Detects if Node.js crypto module is available
+ * @returns true if Node.js crypto module with hash and random functions is available
+ * @example
+ * ```ts
+ * if (isNodeCryptoAvailable()) {
+ *   const crypto = require('crypto')
+ *   const hash = crypto.createHash('sha256')
+ * }
+ * ```
+ */
+declare const isNodeCryptoAvailable: () => boolean;
+/**
+ * Gets the current environment type with automatic detection
+ * @returns The detected environment type
+ * @example
+ * ```ts
+ * const env = getEnvironmentType()
+ * switch (env) {
+ *   case 'node': console.log('Server-side'); break
+ *   case 'browser': console.log('Client-side'); break
+ *   case 'worker': console.log('Worker thread'); break
+ *   case 'unknown': console.log('Unknown environment'); break
+ * }
+ * ```
+ */
+declare const getEnvironmentType: () => "node" | "browser" | "worker" | "unknown";
+/**
+ * Gets available crypto capabilities for the current environment
+ * @returns Object containing crypto capability information
+ * @example
+ * ```ts
+ * const caps = getCryptoCapabilities()
+ * console.log(caps)
+ * // {
+ * //   webCrypto: true,
+ * //   nodeCrypto: false,
+ * //   fallbackOnly: false,
+ * //   environment: 'browser'
+ * // }
+ * ```
+ */
+declare const getCryptoCapabilities: () => {
+    webCrypto: boolean;
+    nodeCrypto: boolean;
+    fallbackOnly: boolean;
+    environment: "node" | "browser" | "worker" | "unknown";
+};
+
+export { getCryptoCapabilities, getEnvironmentType, isBrowserEnv, isNodeCryptoAvailable, isNodeEnv, isWebCryptoAvailable, isWorkerEnvironment };

package/dist/types/environment.d.ts

@@ -0,0 +1 @@
+export { b as EnvironmentCriteria, E as EnvironmentInfo, j as detectHostname, h as detectProtocol, m as getEnvironmentInfo, o as isBrowser, i as isBrowserEnvironment, c as isDevelopment, k as isLocalhost, n as isNode, a as isNodeEnvironment, g as isNonProduction, l as isPrivateIP, d as isProduction, f as isTest, p as parseEnvValue } from './environment-B8eLS7KT.js';

package/dist/types/errors.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Error handling utilities with specific error types and codes
+ * Provides structured error handling for validation, data processing, and environment issues
+ */
+/**
+ * Enumeration of specific error codes for different failure scenarios
+ * @example
+ * ```ts
+ * // Using error codes for type-safe error handling
+ * try {
+ *   validateNIF('invalid')
+ * } catch (error) {
+ *   if (error.code === TsHelpersErrorCode.VALIDATION_FAILED) {
+ *     console.log('Validation error:', error.data)
+ *   }
+ * }
+ * ```
+ */
+declare enum TsHelpersErrorCode {
+    /** Validation of input data failed (NIF, email, etc.) */
+    VALIDATION_FAILED = "VALIDATION_FAILED",
+    /** Error processing data (CSV, JSON, aggregations, etc.) */
+    DATA_PROCESSING_FAILED = "DATA_PROCESSING_FAILED",
+    /** Current environment doesn't support the operation */
+    ENVIRONMENT_NOT_SUPPORTED = "ENVIRONMENT_NOT_SUPPORTED",
+    /** File format not supported for import/export */
+    UNSUPPORTED_FORMAT = "UNSUPPORTED_FORMAT",
+    /** File system operation failed */
+    FILE_ERROR = "FILE_ERROR",
+    /** Network or fetch operation failed */
+    NETWORK_ERROR = "NETWORK_ERROR",
+    /** Invalid operation or function call */
+    INVALID_OPERATION = "INVALID_OPERATION",
+    /** Crypto operation failed (hash, token generation) */
+    CRYPTO_ERROR = "CRYPTO_ERROR",
+    /** Math calculation failed (invalid input, division by zero) */
+    MATH_ERROR = "MATH_ERROR",
+    /** Generic unknown error */
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+/**
+ * Options for creating TsHelpersError instances
+ */
+interface TsHelpersErrorOptions {
+    /** Specific error code for categorization */
+    code?: TsHelpersErrorCode;
+    /** Additional data about the error context */
+    data?: any;
+    /** Original error that caused this error */
+    cause?: Error;
+}
+/**
+ * Main error class for @g10/ts-helpers with structured error information
+ * @example
+ * ```ts
+ * // Creating structured errors
+ * throw new TsHelpersError('Invalid NIF format', {
+ *   code: TsHelpersErrorCode.VALIDATION_FAILED,
+ *   data: { input: '12345', expected: '8 digits + letter' }
+ * })
+ *
+ * // Error handling with type checking
+ * try {
+ *   someOperation()
+ * } catch (error) {
+ *   if (error instanceof TsHelpersError) {
+ *     console.log('Error code:', error.code)
+ *     console.log('Error data:', error.data)
+ *   }
+ * }
+ * ```
+ */
+declare class TsHelpersError extends Error {
+    readonly code?: TsHelpersErrorCode;
+    readonly data?: any;
+    readonly cause?: Error;
+    constructor(message: string, options?: TsHelpersErrorOptions);
+}
+/**
+ * Specialized error class for data processing operations
+ * @example
+ * ```ts
+ * // Data processing errors
+ * throw new DataError(
+ *   'Failed to parse CSV',
+ *   TsHelpersErrorCode.DATA_PROCESSING_FAILED,
+ *   { line: 5, column: 'amount' }
+ * )
+ * ```
+ */
+declare class DataError extends TsHelpersError {
+    constructor(message: string, code?: TsHelpersErrorCode, data?: any);
+}
+/**
+ * Creates a validation error with structured information
+ * @param message - Descriptive error message
+ * @param field - Field name that failed validation
+ * @param value - Value that failed validation
+ * @returns TsHelpersError with validation context
+ * @example
+ * ```ts
+ * // Using in validation functions
+ * if (!isValidEmail(email)) {
+ *   throw createValidationError('Invalid email format', 'email', email)
+ * }
+ *
+ * // Error contains structured data
+ * // error.code === TsHelpersErrorCode.VALIDATION_FAILED
+ * // error.data === { field: 'email', value: 'invalid-email' }
+ * ```
+ */
+declare function createValidationError(message: string, field: string, value: any): TsHelpersError;
+/**
+ * Creates a crypto operation error
+ * @param message - Descriptive error message
+ * @param operation - Crypto operation that failed
+ * @param details - Additional error details
+ * @returns TsHelpersError with crypto context
+ * @example
+ * ```ts
+ * // Using in crypto functions
+ * if (!crypto.getRandomValues) {
+ *   throw createCryptoError('Web Crypto API not available', 'generateSecureToken', {
+ *     environment: 'browser',
+ *     fallback: 'Math.random'
+ *   })
+ * }
+ * ```
+ */
+declare function createCryptoError(message: string, operation: string, details?: any): TsHelpersError;
+/**
+ * Creates a math calculation error
+ * @param message - Descriptive error message
+ * @param operation - Math operation that failed
+ * @param input - Input data that caused the error
+ * @returns TsHelpersError with math context
+ * @example
+ * ```ts
+ * // Using in math functions
+ * if (values.length === 0) {
+ *   throw createMathError('Cannot calculate median of empty array', 'calculateMedian', values)
+ * }
+ * ```
+ */
+declare function createMathError(message: string, operation: string, input?: any): TsHelpersError;
+
+export { DataError, TsHelpersError, TsHelpersErrorCode, type TsHelpersErrorOptions, createCryptoError, createMathError, createValidationError };