@plyaz/db 0.0.0

package/dist/utils/databaseResultHelpers.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @fileoverview Database Result Helper Functions for @plyaz/db package
+ *
+ * This module provides utility functions for creating standardized DatabaseResult objects
+ * used throughout the @plyaz/db package. These helpers ensure consistent result formatting
+ * across all database operations and adapters.
+ *
+ * Part of the @plyaz/db package - a TypeScript database abstraction layer with
+ * support for multiple adapters (Drizzle, Supabase, SQL), extensions (audit, encryption,
+ * soft delete), and advanced features (caching, read replicas, multi-tenancy).
+ *
+ */
+import type { DatabaseResult } from "@plyaz/types/db";
+/**
+ * Creates a successful DatabaseResult wrapper for operation results
+ *
+ * Used throughout all database adapters and extensions to wrap successful operation results
+ * in a consistent format. This enables standardized error handling and result processing
+ * across the entire @plyaz/db package.
+ *
+ * **Used by:**
+ * - All database adapters (DrizzleAdapter, SupabaseAdapter, SQLAdapter)
+ * - All extensions (AuditAdapter, EncryptionAdapter, SoftDeleteAdapter, etc.)
+ * - DatabaseService for operation results
+ * - Repository layer for consistent return types
+ *
+ * @template T - The type of the successful result value
+ * @param {T} value - The successful result value to wrap
+ * @returns {DatabaseResult<T>} A success result object with the value
+ *
+ * @example
+ * ```typescript
+ * import { success } from '@plyaz/db/utils';
+ *
+ * // In adapter methods
+ * async findById<T>(table: string, id: string): Promise<DatabaseResult<T | null>> {
+ *   try {
+ *     const record = await this.db.select().from(table).where(eq(id));
+ *     return success(record[0] || null); // Wrap successful result
+ *   } catch (error) {
+ *     return failure(new DatabaseError('FIND_FAILED', error.message));
+ *   }
+ * }
+ *
+ * // In service methods
+ * const userResult = await userRepository.findById('user-123');
+ * if (userResult.success) {
+ *   console.log('Found user:', userResult.value.name);
+ * }
+ * ```
+ *
+ */
+export declare function success<T = null>(value?: T): DatabaseResult<T>;
+/**
+ * Creates a failed DatabaseResult wrapper for operation errors
+ *
+ * Used throughout all database adapters and extensions to wrap error results
+ * in a consistent format. This enables standardized error handling and result processing
+ * across the entire @plyaz/db package.
+ *
+ * **Used by:**
+ * - All database adapters for error cases
+ * - All extensions for error propagation
+ * - DatabaseService for operation failures
+ * - Repository layer for consistent error handling
+ *
+ * @template T - The type that would have been returned on success
+ * @param {Error} error - The error that occurred during the operation
+ * @returns {DatabaseResult<T>} A failure result object with the error
+ *
+ * @example
+ * ```typescript
+ * import { failure } from '@plyaz/db/utils';
+ * import { DatabaseError } from '@plyaz/errors';
+import { DATABASE_ERROR_CODES } from '@plyaz/types/errors';
+ *
+ * // In adapter methods
+ * async create<T>(table: string, data: T): Promise<DatabaseResult<T>> {
+ *   try {
+ *     const result = await this.db.insert(table).values(data).returning();
+ *     return success(result[0]);
+ *   } catch (error) {
+ *     return failure(new DatabaseError(
+ *       `Failed to create record: ${error.message}`));
+ *   }
+ * }
+ *
+ * // In service layer error handling
+ * const createResult = await userRepository.create(userData);
+ * if (!createResult.success) {
+ *   logger.error('User creation failed:', createResult.error.message);
+ *   throw createResult.error;
+ * }
+ * ```
+ *
+ */
+export declare function failure<T>(error: Error): DatabaseResult<T>;
+//# sourceMappingURL=databaseResultHelpers.d.ts.map

package/dist/utils/databaseResultHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"databaseResultHelpers.d.ts","sourceRoot":"","sources":["../../src/utils/databaseResultHelpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,OAAO,CAAC,CAAC,GAAG,IAAI,EAAE,KAAK,GAAE,CAAa,GAAG,cAAc,CAAC,CAAC,CAAC,CAEzE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,cAAc,CAAC,CAAC,CAAC,CAE1D"}

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./typeGuards";
+export * from "./validation";
+export * from "./databaseResultHelpers";
+export * from "./pagination";
+export * from "./ConfigMerger";
+export * from "./normalizeDetails";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC"}

package/dist/utils/normalizeDetails.d.ts

@@ -0,0 +1,111 @@
+/**
+ * @fileoverview Detail Normalization Utilities for @plyaz/db package
+ *
+ * This module provides utilities for normalizing various data types into consistent
+ * string-based record formats. Used throughout the @plyaz/db package for standardizing
+ * error details, health status information, and event metadata.
+ *
+ * Part of the @plyaz/db package - a TypeScript database abstraction layer with
+ * support for multiple adapters (Drizzle, Supabase, SQL), extensions (audit, encryption,
+ * soft delete), and advanced features (caching, read replicas, multi-tenancy).
+ *
+ */
+/**
+ * Normalizes any input into a standardized Record<string, string> format
+ *
+ * Converts various data types into a consistent string-based record format
+ * for use in error details, health status information, and event metadata.
+ * Provides safe handling of different input types with fallback strategies.
+ *
+ * **Normalization Rules:**
+ * - Objects: Converts all property values to strings while preserving keys
+ * - Primitives: Wraps in { info: stringValue } format
+ * - null/undefined: Returns undefined (no details)
+ * - Arrays: Converts to { info: stringified array }
+ * - Errors: Safely handles conversion failures
+ *
+ * **Used by:**
+ * - HealthManager for health status details
+ * - DatabaseEventEmitter for event metadata
+ * - Error handling throughout adapter chain
+ * - Audit logging for consistent detail formatting
+ *
+ * @param {unknown} details - Input details of any type to normalize
+ * @returns {Record<string, string> | undefined} Normalized details as string record or undefined
+ *
+ * @example
+ * ```typescript
+ * import { normalizeDetails } from '@plyaz/db/utils';
+ *
+ * // Object normalization
+ * const objDetails = normalizeDetails({
+ *   count: 42,
+ *   active: true,
+ *   name: 'test'
+ * });
+ * console.log(objDetails);
+ * // { count: "42", active: "true", name: "test" }
+ *
+ * // Primitive normalization
+ * const stringDetails = normalizeDetails("Connection timeout");
+ * console.log(stringDetails);
+ * // { info: "Connection timeout" }
+ *
+ * // Number normalization
+ * const numberDetails = normalizeDetails(404);
+ * console.log(numberDetails);
+ * // { info: "404" }
+ *
+ * // Null/undefined handling
+ * const nullDetails = normalizeDetails(null);
+ * console.log(nullDetails);
+ * // undefined
+ *
+ * // Array normalization
+ * const arrayDetails = normalizeDetails(['error1', 'error2']);
+ * console.log(arrayDetails);
+ * // { info: "error1,error2" }
+ *
+ * // Error object normalization
+ * const errorDetails = normalizeDetails(new Error('Database error'));
+ * console.log(errorDetails);
+ * // { info: "Error: Database error" }
+ * ```
+ *
+ * @example
+ * ### Usage in Health Status
+ * ```typescript
+ * // In HealthManager.checkHealth()
+ * const healthStatus = {
+ *   isHealthy: true,
+ *   responseTime: 150,
+ *   details: normalizeDetails({
+ *     adapter: 'drizzle',
+ *     connections: 5,
+ *     lastQuery: new Date()
+ *   })
+ * };
+ * // details: { adapter: "drizzle", connections: "5", lastQuery: "2024-01-01T10:00:00.000Z" }
+ * ```
+ *
+ * @example
+ * ### Usage in Error Handling
+ * ```typescript
+ * // In adapter error handling
+ * catch (error) {
+ *   return failure(new DatabaseError(
+ *     'QUERY_FAILED',
+ *     HTTP_STATUS.INTERNAL_SERVER_ERROR,
+ *     'Query execution failed',
+ *     normalizeDetails({
+ *       query: sql,
+ *       params: queryParams,
+ *       originalError: error.message
+ *     })
+ *   ));
+ * }
+ * ```
+ *
+ */
+export declare function normalizeDetails(details: unknown): Record<string, string> | undefined;
+//# sourceMappingURL=normalizeDetails.d.ts.map

package/dist/utils/normalizeDetails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeDetails.d.ts","sourceRoot":"","sources":["../../src/utils/normalizeDetails.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,OAAO,GACf,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CA8BpC"}

package/dist/utils/pagination.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview Pagination Utilities for @plyaz/db package
+ *
+ * This module provides pagination calculation utilities used across all database adapters
+ * to generate consistent pagination metadata for query results. Supports offset-based
+ * pagination with page calculation and validation.
+ *
+ * Part of the @plyaz/db package - a TypeScript database abstraction layer with
+ * support for multiple adapters (Drizzle, Supabase, SQL), extensions (audit, encryption,
+ * soft delete), and advanced features (caching, read replicas, multi-tenancy).
+ *
+ * @module pagination
+ */
+import type { PaginationInfo, PaginationOptions } from "@plyaz/types";
+/**
+ * Calculates comprehensive pagination metadata for database query results
+ *
+ * Generates pagination information used by all database adapters to provide
+ * consistent pagination metadata in query results. Supports both paginated
+ * and non-paginated queries with automatic page calculation.
+ *
+ * **Used by:**
+ * - DrizzleAdapter.findMany() for ORM-based pagination
+ * - SupabaseAdapter.findMany() for Supabase pagination
+ * - SQLAdapter.findMany() for raw SQL pagination
+ * - All repository methods that return paginated results
+ *
+ * **Calculation Logic:**
+ * - Page numbers are 1-based (first page = 1)
+ * - Current page = floor(offset / limit) + 1
+ * - Total pages = ceil(total / limit)
+ * - Handles edge cases (no limit, empty results, etc.)
+ *
+ * @param {number} total - Total number of items matching the query
+ * @param {PaginationOptions} [options] - Optional pagination configuration
+ * @param {number} [options.limit] - Maximum items per page
+ * @param {number} [options.offset] - Number of items to skip (default: 0)
+ * @returns {PaginationInfo} Complete pagination metadata object
+ *
+ * @example
+ * ```typescript
+ * import { calculatePagination } from '@plyaz/db/utils';
+ *
+ * // Standard pagination (page 2 of 20 items per page)
+ * const pagination1 = calculatePagination(100, { limit: 20, offset: 20 });
+ * console.log(pagination1);
+ * // {
+ * //   page: 2,
+ * //   limit: 20,
+ * //   offset: 20,
+ * //   totalPages: 5
+ * // }
+ *
+ * // First page
+ * const pagination2 = calculatePagination(100, { limit: 20, offset: 0 });
+ * console.log(pagination2);
+ * // {
+ * //   page: 1,
+ * //   limit: 20,
+ * //   offset: 0,
+ * //   totalPages: 5
+ * // }
+ *
+ * // No pagination (return all results)
+ * const pagination3 = calculatePagination(100);
+ * console.log(pagination3);
+ * // {
+ * //   page: undefined,
+ * //   limit: undefined,
+ * //   offset: 0,
+ * //   totalPages: undefined
+ * // }
+ * ```
+ *
+ */
+export declare function calculatePagination(total: number, options?: PaginationOptions): PaginationInfo;
+//# sourceMappingURL=pagination.d.ts.map

package/dist/utils/pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../src/utils/pagination.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAiFtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,iBAAiB,GAC1B,cAAc,CAyBhB"}

package/dist/utils/regex.d.ts

@@ -0,0 +1,199 @@
+/**
+ * @fileoverview Centralized Regex Patterns for @plyaz/db package
+ *
+ * This module contains all regex patterns used throughout the database package.
+ * Centralizing regex patterns improves maintainability, reusability, and consistency.
+ *
+ * Part of the @plyaz/db package - a TypeScript database abstraction layer with
+ * support for multiple adapters (Drizzle, Supabase, SQL), extensions (audit, encryption,
+ * soft delete), and advanced features (caching, read replicas, multi-tenancy).
+ *
+ */
+/**
+ * Database field and table name validation patterns
+ * Used for SQL injection prevention and database identifier validation
+ */
+export declare const DATABASE_PATTERNS: {
+    /**
+     * Validates database field names (columns)
+     * - Must start with letter (a-z, A-Z) or underscore (_)
+     * - Can contain letters, numbers, and underscores
+     * - Prevents SQL injection through field names
+     *
+     * Used in: validation.ts, sql.ts, DrizzleAdapter.ts, SQLAdapter.ts
+     */
+    readonly FIELD_NAME: RegExp;
+    /**
+     * Validates database table names
+     * - Same rules as field names for consistency
+     * - Follows SQL identifier naming conventions
+     *
+     * Used in: validation.ts, CacheEvict.decorator.ts
+     */
+    readonly TABLE_NAME: RegExp;
+};
+/**
+ * Cache key validation patterns
+ * Used for validating cache keys and patterns in caching system
+ */
+export declare const CACHE_PATTERNS: {
+    /**
+     * Validates cache keys
+     * - Allows letters, numbers, colons, underscores, and hyphens
+     * - Used for Redis cache key validation
+     *
+     * Used in: CacheEvict.decorator.ts
+     */
+    readonly CACHE_KEY: RegExp;
+    /**
+     * Validates cache patterns (with wildcards)
+     * - Same as cache key but allows asterisk (*) for wildcards
+     * - Used for cache pattern matching and eviction
+     *
+     * Used in: CacheEvict.decorator.ts
+     */
+    readonly CACHE_PATTERN: RegExp;
+};
+/**
+ * SQL query sanitization patterns
+ * Used for cleaning and normalizing SQL queries for metrics and logging
+ */
+export declare const SQL_PATTERNS: {
+    /**
+     * Matches PostgreSQL parameter placeholders ($1, $2, etc.)
+     * - Used to normalize parameterized queries for metrics
+     *
+     * Used in: MetricsCollector.ts
+     */
+    readonly POSTGRES_PARAMS: RegExp;
+    /**
+     * Matches numeric values in SQL queries
+     * - Used to replace numbers with placeholders for query normalization
+     *
+     * Used in: MetricsCollector.ts
+     */
+    readonly NUMERIC_VALUES: RegExp;
+    /**
+     * Matches string literals in SQL queries (single quotes)
+     * - Used to replace string values with placeholders
+     *
+     * Used in: MetricsCollector.ts
+     */
+    readonly STRING_LITERALS: RegExp;
+};
+/**
+ * Input sanitization patterns
+ * Used for cleaning user input and preventing injection attacks
+ */
+export declare const SANITIZATION_PATTERNS: {
+    /**
+     * Matches dangerous characters for SQL injection prevention
+     * - Null byte, backspace, tab, newline, carriage return
+     * - Single and double quotes, backslashes, percent signs
+     *
+     * Used in: validation.ts (sanitizeInput function)
+     */
+    readonly DANGEROUS_CHARS: RegExp;
+    /**
+     * Matches shell metacharacters for command injection prevention
+     * - Semicolon, ampersand, pipe, backtick, dollar, parentheses, etc.
+     *
+     * Used in: BackupService.ts (sanitizeCommand function)
+     */
+    readonly SHELL_METACHARACTERS: RegExp;
+    /**
+     * Matches multiple whitespace characters
+     * - Used to normalize whitespace in sanitized input
+     *
+     * Used in: BackupService.ts
+     */
+    readonly MULTIPLE_WHITESPACE: RegExp;
+    /**
+     * Matches line breaks and tabs
+     * - Used to replace line breaks with spaces
+     *
+     * Used in: BackupService.ts
+     */
+    readonly LINE_BREAKS_TABS: RegExp;
+    /**
+     * Matches Unicode control characters
+     * - Uses Unicode property escape to match all control characters
+     *
+     * Used in: BackupService.ts
+     */
+    readonly CONTROL_CHARACTERS: RegExp;
+};
+/**
+ * File and path patterns
+ * Used for file operations and path validation
+ */
+export declare const FILE_PATTERNS: {
+    /**
+     * Matches colon and dot characters in timestamps
+     * - Used to create filesystem-safe timestamps
+     *
+     * Used in: BackupService.ts (timestamp generation)
+     */
+    readonly TIMESTAMP_CHARS: RegExp;
+};
+/**
+ * Utility functions for common regex operations
+ */
+export declare const DB_REGEX: {
+    /**
+     * Tests if a string matches the database field name pattern
+     * @param fieldName - The field name to validate
+     * @returns True if valid database field name
+     */
+    readonly isValidFieldName: (fieldName: string) => boolean;
+    /**
+     * Tests if a string matches the database table name pattern
+     * @param tableName - The table name to validate
+     * @returns True if valid database table name
+     */
+    readonly isValidTableName: (tableName: string) => boolean;
+    /**
+     * Tests if a string matches the cache key pattern
+     * @param cacheKey - The cache key to validate
+     * @returns True if valid cache key
+     */
+    readonly isValidCacheKey: (cacheKey: string) => boolean;
+    /**
+     * Tests if a string matches the cache pattern (with wildcards)
+     * @param cachePattern - The cache pattern to validate
+     * @returns True if valid cache pattern
+     */
+    readonly isValidCachePattern: (cachePattern: string) => boolean;
+    /**
+     * Normalizes SQL query by replacing parameters and values with placeholders
+     * @param query - The SQL query to normalize
+     * @returns Normalized query string
+     */
+    readonly normalizeSqlQuery: (query: string) => string;
+    /**
+     * Sanitizes input by escaping dangerous characters
+     * @param input - The input string to sanitize
+     * @param escapeMap - Map of characters to their escaped equivalents
+     * @returns Sanitized string
+     */
+    readonly sanitizeDangerousChars: (input: string, escapeMap: Record<string, string>) => string;
+    /**
+     * Creates filesystem-safe timestamp string
+     * @param timestamp - ISO timestamp string
+     * @returns Filesystem-safe timestamp
+     */
+    readonly createSafeTimestamp: (timestamp: string) => string;
+    /**
+     * Sanitizes command string by removing shell metacharacters
+     * @param command - Command string to sanitize
+     * @returns Sanitized command string
+     */
+    readonly sanitizeCommand: (command: string) => string;
+    /**
+     * Sanitizes log message by normalizing whitespace and removing control characters
+     * @param message - Log message to sanitize
+     * @returns Sanitized log message
+     */
+    readonly sanitizeLogMessage: (message: string) => string;
+};
+//# sourceMappingURL=regex.d.ts.map

package/dist/utils/regex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.d.ts","sourceRoot":"","sources":["../../src/utils/regex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB;IAC5B;;;;;;;OAOG;;IAGH;;;;;;OAMG;;CAEK,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;;OAMG;;IAGH;;;;;;OAMG;;CAEK,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;CAEK,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,qBAAqB;IAChC;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;CAEK,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,aAAa;IACxB;;;;;OAKG;;CAEK,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,QAAQ;IACnB;;;;OAIG;2CAC2B,MAAM,KAAG,OAAO;IAI9C;;;;OAIG;2CAC2B,MAAM,KAAG,OAAO;IAI9C;;;;OAIG;yCACyB,MAAM,KAAG,OAAO;IAI5C;;;;OAIG;iDACiC,MAAM,KAAG,OAAO;IAIpD;;;;OAIG;wCACwB,MAAM,KAAG,MAAM;IAO1C;;;;;OAKG;6CAEM,MAAM,aACF,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAChC,MAAM;IAOT;;;;OAIG;8CAC8B,MAAM,KAAG,MAAM;IAIhD;;;;OAIG;wCACwB,MAAM,KAAG,MAAM;IAO1C;;;;OAIG;2CAC2B,MAAM,KAAG,MAAM;CAMrC,CAAC"}

package/dist/utils/typeGuards.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview Type Guard Utilities for @plyaz/db package
+ *
+ * This module provides type guard functions for runtime type checking throughout
+ * the @plyaz/db package. These utilities replace direct typeof checks with
+ * consistent, reusable type validation functions.
+ *
+ */
+/**
+ * Type guard to check if a value is a string
+ *
+ * @param {unknown} value - The value to check
+ * @returns {value is string} True if value is a string, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { isString } from '@plyaz/db/utils';
+ *
+ * if (isString(userInput)) {
+ *   // userInput is now typed as string
+ *   console.log(userInput.toLowerCase());
+ * }
+ * ```
+ */
+export declare function isString(value: unknown): value is string;
+/**
+ * Type guard to check if a value is a non-empty string
+ *
+ * @param {unknown} value - The value to check
+ * @returns {value is string} True if value is a non-empty string, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { isNonEmptyString } from '@plyaz/db/utils';
+ *
+ * if (isNonEmptyString(tableName)) {
+ *   // tableName is guaranteed to be a non-empty string
+ *   const query = `SELECT * FROM ${tableName}`;
+ * }
+ * ```
+ */
+export declare function isNonEmptyString(value: unknown): value is string;
+/**
+ * Type guard to check if a value is a number
+ *
+ * @param {unknown} value - The value to check
+ * @returns {value is number} True if value is a number, false otherwise
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Type guard to check if a value is an object (not null, not array)
+ *
+ * @param {unknown} value - The value to check
+ * @returns {value is object} True if value is an object, false otherwise
+ */
+export declare function isObject(value: unknown): value is object;
+//# sourceMappingURL=typeGuards.d.ts.map

package/dist/utils/typeGuards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["../../src/utils/typeGuards.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD"}