@jmruthers/pace-core 0.6.9 → 0.6.11

package/dist/timezone-BTWWXKVY.d.ts

@@ -0,0 +1,696 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { z } from 'zod';
+import { ClassValue } from 'clsx';
+import { D as Database } from './database.generated-qkdoiVrJ.js';
+
+/**
+ * Hook for manual session tracking (event switches and session expiration).
+ *
+ * Note: Login and logout tracking is automatically handled by UnifiedAuthProvider.
+ * You should only use this hook for tracking event switches or session expirations.
+ *
+ * @param supabaseClient - Supabase client instance
+ * @param appName - Optional application name for tracking
+ * @returns Object containing tracking functions for event switches and session expiration
+ */
+declare function useSessionTracking(supabaseClient: SupabaseClient, appName?: string): {
+    trackEventSwitch: (eventId: string) => Promise<void>;
+    trackSessionExpired: () => Promise<void>;
+};
+
+/**
+ * @file Common validation schemas
+ * @description Reusable validation schemas for common data types
+ */
+
+/**
+ * Email validation schema
+ */
+declare const emailSchema: z.ZodString;
+/**
+ * Name validation schema
+ */
+declare const nameSchema: z.ZodString;
+/**
+ * Phone number validation schema
+ */
+declare const phoneSchema: z.ZodString;
+/**
+ * URL validation schema
+ */
+declare const urlSchema: z.ZodString;
+/**
+ * Date validation schema
+ */
+declare const dateSchema: z.ZodEffects<z.ZodString, string, string>;
+
+/**
+ * @file Enhanced Password Schema with Security Validations
+ * @description Comprehensive password validation with security checks
+ */
+
+/**
+ * Basic password schema for less strict requirements
+ */
+declare const passwordSchema: z.ZodString;
+/**
+ * Password strength calculator
+ */
+declare function calculatePasswordStrength(password: string): {
+    score: number;
+    feedback: string[];
+    level: 'very-weak' | 'weak' | 'fair' | 'good' | 'strong';
+};
+
+/**
+ * @file HTML Sanitization Utilities
+ * @package @jmruthers/pace-core
+ * @module Utils/Validation/HTMLSanitization
+ * @since 0.4.36
+ *
+ * Utilities for safely rendering HTML content.
+ * Provides sanitization and validation for basic HTML elements.
+ */
+/**
+ * Basic HTML sanitization function using regex-based approach
+ * Removes potentially dangerous elements and attributes while preserving basic formatting
+ * This approach is more reliable in SSR environments and doesn't require DOM manipulation
+ *
+ * @param html - The HTML string to sanitize
+ * @returns Sanitized HTML string safe for rendering
+ *
+ * @example
+ * ```tsx
+ * const safeHtml = sanitizeHtml('<p>Hello <strong>world</strong>!</p>');
+ * // Returns: '<p>Hello <strong>world</strong>!</p>'
+ *
+ * const dangerousHtml = sanitizeHtml('<script>alert("xss")</script><p>Safe content</p>');
+ * // Returns: '<p>Safe content</p>'
+ * ```
+ */
+declare function sanitizeHtml(html: string): string;
+/**
+ * Validates if HTML content is safe for rendering
+ *
+ * @param html - The HTML string to validate
+ * @returns Object with validation result and any warnings
+ *
+ * @example
+ * ```tsx
+ * const validation = validateHtml('<p>Safe content</p>');
+ * console.log(validation.isValid); // true
+ * console.log(validation.warnings); // []
+ * ```
+ */
+declare function validateHtml(html: string): {
+    isValid: boolean;
+    warnings: string[];
+};
+/**
+ * Safely renders HTML content with sanitization
+ *
+ * @param html - The HTML string to render
+ * @param options - Rendering options
+ * @returns Object with sanitized HTML and validation info
+ *
+ * @example
+ * ```tsx
+ * const result = renderSafeHtml('<p>Hello <strong>world</strong>!</p>');
+ * console.log(result.html); // Sanitized HTML
+ * console.log(result.isValid); // true
+ * ```
+ */
+declare function renderSafeHtml(html: string, options?: {
+    logWarnings?: boolean;
+}): {
+    html: string;
+    isValid: boolean;
+    warnings: string[];
+};
+
+/**
+ * @file Input Sanitization Layer
+ * @package @jmruthers/pace-core
+ * @module Utils/Validation/Sanitization
+ * @since 0.1.0
+ *
+ * Comprehensive input sanitization utilities to prevent XSS, injection attacks,
+ * and other security vulnerabilities.
+ */
+
+/**
+ * Sanitization options for different contexts
+ */
+interface SanitizationOptions {
+    allowHtml?: boolean;
+    allowedTags?: string[];
+    maxLength?: number;
+    trim?: boolean;
+    removeScripts?: boolean;
+    removeEvents?: boolean;
+}
+/**
+ * Sanitizes user input by removing potentially dangerous characters and patterns
+ */
+declare function sanitizeUserInput(input: string, options?: SanitizationOptions): string;
+/**
+ * Validates and sanitizes form data using Zod schemas
+ */
+declare function sanitizeFormData<T>(data: unknown, schema: z.ZodSchema<T>, sanitizationRules?: Record<string, SanitizationOptions>): {
+    success: boolean;
+    data?: T;
+    error?: string;
+};
+
+/**
+ * @file Secure Data Access Utility
+ * @package @jmruthers/pace-core
+ * @module Utils/SecureDataAccess
+ * @since 0.4.0
+ *
+ * Secure data access utilities that enforce organisation context for all database operations.
+ * Prevents data leakage between organisations and ensures proper access validation.
+ */
+
+interface DatabaseRecord {
+    id: string;
+    organisation_id: string;
+    [key: string]: unknown;
+}
+interface DatabaseData {
+    [key: string]: unknown;
+}
+interface DatabaseFilters {
+    [key: string]: unknown;
+}
+interface SecureQueryOptions {
+    table: string;
+    select: string;
+    organisationId: string;
+    filters?: DatabaseFilters;
+    orderBy?: string;
+    limit?: number;
+    offset?: number;
+}
+interface SecureDataAccess {
+    secureQuery: <T extends DatabaseRecord = DatabaseRecord>(options: SecureQueryOptions) => Promise<T[]>;
+    secureSingleQuery: <T extends DatabaseRecord = DatabaseRecord>(options: SecureQueryOptions) => Promise<T | null>;
+    secureInsert: <T extends DatabaseRecord = DatabaseRecord>(table: string, data: DatabaseData, organisationId: string) => Promise<T | null>;
+    secureUpdate: <T extends DatabaseRecord = DatabaseRecord>(table: string, data: DatabaseData, filters: DatabaseFilters, organisationId: string) => Promise<T | null>;
+    secureDelete: (table: string, filters: DatabaseFilters, organisationId: string) => Promise<boolean>;
+    queryByOrganisation: <T extends DatabaseRecord = DatabaseRecord>(table: string, select: string, organisationId: string, filters?: DatabaseFilters) => Promise<T[]>;
+    validateOrganisationContext: (organisationId: string) => void;
+    ensureOrganisationColumn: (table: string) => boolean;
+}
+/**
+ * Create a secure data access instance
+ * @param supabase - Supabase client instance
+ * @param organisationId - Current organisation context
+ * @param isSuperAdmin - Whether user has super admin privileges
+ * @returns Secure data access utilities
+ */
+declare const createSecureDataAccess: (supabase: SupabaseClient, organisationId: string, isSuperAdmin?: boolean) => SecureDataAccess;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+/**
+ * Application configuration utilities
+ */
+interface AppConfig {
+    appName: string;
+    appId: string;
+}
+/**
+ * Set the current application configuration
+ */
+declare function setAppConfig(config: AppConfig): void;
+/**
+ * Get the current application configuration
+ */
+declare function getAppConfig(): AppConfig;
+/**
+ * Get the current app name
+ */
+declare function getCurrentAppName(): string;
+/**
+ * Get the current app ID
+ */
+declare function getCurrentAppId(): string;
+
+/**
+ * @file Base Supabase Client Creation Utility
+ * @package @jmruthers/pace-core
+ * @module Utils/Supabase
+ * @since 0.6.6
+ *
+ * Restricted wrapper for creating the base Supabase client for UnifiedAuthProvider.
+ * This is the ONLY acceptable way to create a Supabase client in consuming apps.
+ *
+ * @example
+ * ```tsx
+ * // ✅ CORRECT: In main.tsx, App.tsx, or lib/supabase.ts
+ * import { createBaseClient } from '@jmruthers/pace-core';
+ *
+ * const supabase = createBaseClient(
+ *   import.meta.env.VITE_SUPABASE_URL,
+ *   import.meta.env.VITE_SUPABASE_PUBLISHABLE_KEY
+ * );
+ *
+ * // Pass to UnifiedAuthProvider
+ * <UnifiedAuthProvider supabaseClient={supabase} ... />
+ * ```
+ */
+
+/**
+ * Create a base Supabase client for UnifiedAuthProvider
+ *
+ * **CRITICAL**: This function can ONLY be called from:
+ * - `src/main.tsx` (or `main.jsx`)
+ * - `src/App.tsx` (or `App.jsx`)
+ * - `src/lib/supabase.ts` (or `supabase.js`)
+ * - `src/supabase.ts` (or `supabase.js`)
+ *
+ * **DO NOT** use this client directly for queries. Always use `useSecureSupabase()` hook instead.
+ *
+ * The client is configured with explicit auth options to ensure consistent session persistence:
+ * - `persistSession: true` - Sessions are saved to localStorage and restored on page load/refresh
+ * - `autoRefreshToken: true` - Tokens are automatically refreshed before expiry
+ * - `detectSessionInUrl: true` - Detects and handles OAuth callback URLs
+ * - `flowType: 'pkce'` - Uses PKCE flow for enhanced security
+ *
+ * This configuration ensures that users remain logged in after hard refresh (Cmd+Shift+R)
+ * and other browser navigation scenarios across all consuming apps.
+ *
+ * @param supabaseUrl - Supabase project URL
+ * @param supabaseKey - Supabase publishable key or anon key (accepts both legacy anon keys and modern publishable keys)
+ * @returns Supabase client instance with auth configuration
+ *
+ * @throws {Error} If called from an unauthorized file location (development only)
+ *
+ * @example
+ * ```tsx
+ * // main.tsx
+ * import { createBaseClient } from '@jmruthers/pace-core';
+ * import { UnifiedAuthProvider } from '@jmruthers/pace-core';
+ *
+ * const supabase = createBaseClient(
+ *   import.meta.env.VITE_SUPABASE_URL,
+ *   import.meta.env.VITE_SUPABASE_PUBLISHABLE_KEY
+ * );
+ *
+ * function App() {
+ *   return (
+ *     <UnifiedAuthProvider supabaseClient={supabase} appName="MyApp">
+ *       <YourApp />
+ *     </UnifiedAuthProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function createBaseClient(supabaseUrl: string, supabaseKey: string): SupabaseClient<Database>;
+
+/**
+ * @file Production-Safe Logger Utility
+ * @package @jmruthers/pace-core
+ * @module Utils/Logger
+ * @since 0.4.76
+ */
+/**
+ * Logger levels for different types of messages
+ */
+declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+/**
+ * Logger configuration interface
+ */
+interface LoggerConfig {
+    /** Minimum log level to output */
+    level: LogLevel;
+    /** Whether to include timestamps */
+    includeTimestamp: boolean;
+    /** Whether to include component names */
+    includeComponent: boolean;
+    /** Custom prefix for all log messages */
+    prefix?: string;
+}
+/**
+ * Production-safe logger that no-ops in production builds
+ * Only outputs logs in development mode to prevent production console spam
+ */
+declare class Logger {
+    private static config;
+    /**
+     * Check if we're in development or test mode
+     * Allows logging in both development and test environments
+     */
+    private static get isDevelopment();
+    /**
+     * Configure the logger
+     */
+    static configure(config: Partial<LoggerConfig>): void;
+    /**
+     * Format a log message with optional timestamp and component
+     */
+    private static formatMessage;
+    /**
+     * Check if a log level should be output
+     */
+    private static shouldLog;
+    /**
+     * Log debug information (development only)
+     */
+    static debug(component: string, message: string, ...args: unknown[]): void;
+    /**
+     * Log info information (development only)
+     */
+    static info(component: string, message: string, ...args: unknown[]): void;
+    /**
+     * Log warning information (development only)
+     */
+    static warn(component: string, message: string, ...args: unknown[]): void;
+    /**
+     * Log error information (development only)
+     */
+    static error(component: string, message: string, ...args: unknown[]): void;
+    /**
+     * Create a scoped logger for a specific component
+     */
+    static createScopedLogger(component: string): {
+        debug: (message: string, ...args: unknown[]) => void;
+        info: (message: string, ...args: unknown[]) => void;
+        warn: (message: string, ...args: unknown[]) => void;
+        error: (message: string, ...args: unknown[]) => void;
+    };
+}
+/**
+ * Default logger instance for convenience
+ */
+declare const logger: {
+    debug: (component: string, message: string, ...args: unknown[]) => void;
+    info: (component: string, message: string, ...args: unknown[]) => void;
+    warn: (component: string, message: string, ...args: unknown[]) => void;
+    error: (component: string, message: string, ...args: unknown[]) => void;
+    createScopedLogger: (component: string) => {
+        debug: (message: string, ...args: unknown[]) => void;
+        info: (message: string, ...args: unknown[]) => void;
+        warn: (message: string, ...args: unknown[]) => void;
+        error: (message: string, ...args: unknown[]) => void;
+    };
+    configure: (config: Partial<LoggerConfig>) => void;
+};
+/**
+ * Convenience function to create a scoped logger
+ */
+declare function createLogger(component: string): {
+    debug: (message: string, ...args: unknown[]) => void;
+    info: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+};
+
+/**
+ * Utility functions for formatting data in the application
+ */
+/**
+ * Format a date as a readable string in "dd mmm yyyy" format (e.g., "15 Jun 2024")
+ */
+declare function formatDate(date: Date | string | number): string;
+/**
+ * Format a time as a readable string in "HH:mm" format (e.g., "14:30")
+ * Uses 24-hour format for consistency across pace apps
+ */
+declare function formatTime(date: Date | string | number): string;
+/**
+ * Format a date and time as a readable string in "dd mmm yyyy, HH:mm" format (e.g., "15 Jun 2024, 14:30")
+ * Uses 24-hour format for consistency across pace apps
+ */
+declare function formatDateTime(date: Date | string | number): string;
+/**
+ * Format a number as a currency
+ */
+declare function formatCurrency(value: number, currencyCode?: string, locale?: string): string;
+/**
+ * Format a number with custom options
+ */
+declare function formatNumber(value: number, options?: Intl.NumberFormatOptions, locale?: string): string;
+/**
+ * Format a number as a percentage.
+ *
+ * @param value - The percentage value as a decimal (e.g., 0.81 for 0.81%)
+ * @param locale - The locale string (default: 'en-US')
+ * @param options - Options object with:
+ *   - `decimals` - Fixed number of decimal places (default: 1)
+ *   - `preserveDecimals` - Auto-detect and preserve decimal places from the input value
+ *   - `maxDecimals` - Maximum decimal places when preserving (default: 10)
+ * @returns Formatted percentage string (e.g., "0.81%", "81%")
+ *
+ * @example
+ * ```ts
+ * // Fixed decimals (default behavior)
+ * formatPercent(0.5) // '0.5%'
+ * formatPercent(0.81, 'en-US', { decimals: 1 }) // '0.8%' (loses precision)
+ *
+ * // Preserve decimal places dynamically
+ * formatPercent(0.81, 'en-US', { preserveDecimals: true }) // '0.81%'
+ * formatPercent(0.8123, 'en-US', { preserveDecimals: true, maxDecimals: 2 }) // '0.81%'
+ * ```
+ */
+declare function formatPercent(value: number, locale?: string, options?: {
+    decimals?: number;
+    preserveDecimals?: boolean;
+    maxDecimals?: number;
+}): string;
+/**
+ * Format a large number with abbreviations (K, M, B)
+ */
+declare function formatCompactNumber(value: number, locale?: string): string;
+/**
+ * Format a file size in bytes to a human-readable string
+ */
+declare function formatFileSize(bytes: number): string;
+/**
+ * Options for formatting date/time with timezone
+ */
+interface DateTimeFormatOptions {
+    /**
+     * Include timezone abbreviation (default: true)
+     */
+    includeTimezone?: boolean;
+    /**
+     * Custom format string (default: 'MMM dd, yyyy HH:mm')
+     */
+    format?: string;
+}
+/**
+ * Format a UTC date for display in a specific timezone
+ *
+ * @param utcDate - UTC date (ISO string, Date object, or undefined)
+ * @param timezone - IANA timezone string (e.g., 'America/New_York')
+ * @param options - Formatting options
+ * @returns Formatted date string or empty string if invalid
+ *
+ * @example
+ * ```ts
+ * formatDateTimeForDisplay('2024-01-15T10:00:00Z', 'America/New_York');
+ * // "Jan 15, 2024 05:00 (EST)"
+ *
+ * formatDateTimeForDisplay('2024-01-15T10:00:00Z', 'America/New_York', { includeTimezone: false });
+ * // "Jan 15, 2024 05:00"
+ * ```
+ */
+declare function formatDateTimeForDisplay(utcDate: string | Date | undefined, timezone: string | undefined, options?: DateTimeFormatOptions): string;
+/**
+ * Format a UTC date for display (date only, no time)
+ *
+ * @param utcDate - UTC date (ISO string, Date object, or undefined)
+ * @returns Formatted date string or empty string if invalid
+ *
+ * @example
+ * ```ts
+ * formatDateOnlyForDisplay('2024-01-15T10:00:00Z');
+ * // "15 January 2024"
+ * ```
+ */
+declare function formatDateOnlyForDisplay(utcDate: string | Date | undefined): string;
+/**
+ * Format a UTC date for table display (compact format with timezone)
+ *
+ * @param utcDate - UTC date (ISO string, Date object, or undefined)
+ * @param timezone - IANA timezone string
+ * @returns Formatted date string or empty string if invalid
+ *
+ * @example
+ * ```ts
+ * formatDateTimeForTable('2024-01-15T10:00:00Z', 'America/New_York');
+ * // "Jan 15, 2024 05:00 (EST)"
+ * ```
+ */
+declare function formatDateTimeForTable(utcDate: string | Date | undefined, timezone: string | undefined): string;
+/**
+ * Format a UTC date for map display (compact format)
+ *
+ * @param utcDate - UTC date (ISO string, Date object, or undefined)
+ * @param timezone - IANA timezone string
+ * @returns Formatted date string or empty string if invalid
+ *
+ * @example
+ * ```ts
+ * formatDateTimeForMap('2024-01-15T10:00:00Z', 'America/New_York');
+ * // "Jan 15, 05:00 EST"
+ * ```
+ */
+declare function formatDateTimeForMap(utcDate: string | Date | undefined, timezone: string | undefined): string;
+
+/**
+ * @file Timezone Utilities
+ * @package @jmruthers/pace-core
+ * @module Utils/Timezone
+ * @since 0.1.0
+ *
+ * Comprehensive timezone conversion and formatting utilities using date-fns-tz and native Intl APIs.
+ * Provides functions for timezone-aware date operations, conversions, and formatting.
+ *
+ * Features:
+ * - Format dates in specific timezones
+ * - Get timezone abbreviations
+ * - Convert between UTC and timezone local times
+ * - Round dates to nearest minutes
+ * - Calculate timezone differences
+ * - Get user's browser timezone
+ *
+ * @example
+ * ```ts
+ * import { toZonedTime, fromZonedTime, formatInTimeZone, getUserTimeZone } from '@jmruthers/pace-core/utils/timezone';
+ *
+ * // Convert UTC to local timezone
+ * const utcDate = new Date('2024-01-15T10:00:00Z');
+ * const localDate = toZonedTime(utcDate, 'America/New_York');
+ *
+ * // Convert local time to UTC
+ * const localInput = new Date(2024, 0, 15, 10, 0);
+ * const utcDate = fromZonedTime(localInput, 'America/New_York');
+ *
+ * // Format with timezone
+ * const formatted = formatInTimeZone(utcDate, 'America/New_York', 'MMM dd, yyyy HH:mm');
+ * ```
+ */
+/**
+ * Format a date in a specific timezone using date-fns format strings
+ *
+ * @param date - Date to format (Date object, ISO string, or timestamp)
+ * @param timeZone - IANA timezone string (e.g., 'America/New_York')
+ * @param formatStr - date-fns format string (e.g., 'MMM dd, yyyy HH:mm')
+ * @returns Formatted date string or 'Invalid date' on error
+ *
+ * @example
+ * ```ts
+ * formatInTimeZone(new Date('2024-01-15T10:00:00Z'), 'America/New_York', 'MMM dd, yyyy HH:mm');
+ * // "Jan 15, 2024 05:00"
+ * ```
+ */
+declare function formatInTimeZone(date: Date | string | number, timeZone: string, formatStr: string): string;
+/**
+ * Get the timezone abbreviation (EST, PST, etc.) for a date in a specific timezone
+ *
+ * @param date - Date to get abbreviation for
+ * @param timeZone - IANA timezone string
+ * @returns Timezone abbreviation or timezone name on error
+ *
+ * @example
+ * ```ts
+ * getTimezoneAbbreviation(new Date(), 'America/New_York');
+ * // "EST" or "EDT" depending on date
+ * ```
+ */
+declare function getTimezoneAbbreviation(date: Date, timeZone: string): string;
+/**
+ * Format time only in a specific timezone
+ *
+ * @param date - Date to format
+ * @param timeZone - IANA timezone string
+ * @returns Formatted time string (HH:mm format) or 'Invalid date' on error
+ *
+ * @example
+ * ```ts
+ * formatTimeInTimeZone(new Date('2024-01-15T10:00:00Z'), 'America/New_York');
+ * // "05:00"
+ * ```
+ */
+declare function formatTimeInTimeZone(date: Date | string, timeZone: string): string;
+/**
+ * Get the user's local timezone from the browser
+ *
+ * @returns IANA timezone string (e.g., 'America/New_York')
+ *
+ * @example
+ * ```ts
+ * const userTz = getUserTimeZone();
+ * // "America/New_York" or user's actual timezone
+ * ```
+ */
+declare function getUserTimeZone(): string;
+/**
+ * Convert a UTC date to a specific timezone's local time representation
+ *
+ * @param date - UTC date to convert
+ * @param timezone - IANA timezone string
+ * @returns Date object representing local time in the timezone
+ *
+ * @example
+ * ```ts
+ * const utcDate = new Date('2024-01-15T10:00:00Z');
+ * const localDate = toZonedTime(utcDate, 'America/New_York');
+ * // Returns Date object representing 5:00 AM in New York
+ * ```
+ */
+declare function toZonedTime(date: Date, timezone: string): Date;
+/**
+ * Convert a local time in a specific timezone to UTC
+ *
+ * @param localDate - Local date in the timezone
+ * @param timezone - IANA timezone string
+ * @returns Date object in UTC
+ *
+ * @example
+ * ```ts
+ * const localDate = new Date(2024, 0, 15, 10, 0); // Jan 15, 2024 10:00 AM local
+ * const utcDate = fromZonedTime(localDate, 'America/New_York');
+ * // Returns Date object representing 3:00 PM UTC (if EST) or 2:00 PM UTC (if EDT)
+ * ```
+ */
+declare function fromZonedTime(localDate: Date, timezone: string): Date;
+/**
+ * Round a date to the nearest X minutes
+ *
+ * @param date - Date to round
+ * @param minutesStep - Number of minutes to round to (default: 5)
+ * @returns Rounded date
+ *
+ * @example
+ * ```ts
+ * const date = new Date('2024-01-15T10:23:00Z');
+ * roundToNearestMinutes(date, 5);
+ * // Returns Date object for 10:25:00
+ * ```
+ */
+declare function roundToNearestMinutes(date: Date, minutesStep?: number): Date;
+/**
+ * Calculate the time difference between two timezones in hours
+ *
+ * @param fromTimeZone - Source timezone (IANA string)
+ * @param toTimeZone - Target timezone (IANA string)
+ * @returns Difference in hours (positive if toTimeZone is ahead)
+ *
+ * @example
+ * ```ts
+ * getTimeZoneDifference('America/New_York', 'America/Los_Angeles');
+ * // -3 (Los Angeles is 3 hours behind New York)
+ * ```
+ */
+declare function getTimeZoneDifference(fromTimeZone: string, toTimeZone: string): number;
+
+export { formatCompactNumber as A, formatFileSize as B, formatInTimeZone as C, getTimezoneAbbreviation as D, formatTimeInTimeZone as E, getUserTimeZone as F, toZonedTime as G, fromZonedTime as H, roundToNearestMinutes as I, getTimeZoneDifference as J, validateHtml as K, Logger as L, renderSafeHtml as M, dateSchema as N, type SecureDataAccess as O, formatDateTimeForDisplay as P, formatDateOnlyForDisplay as Q, formatDateTimeForTable as R, type SanitizationOptions as S, formatDateTimeForMap as T, type DateTimeFormatOptions as U, calculatePasswordStrength as V, urlSchema as a, passwordSchema as b, sanitizeFormData as c, sanitizeHtml as d, emailSchema as e, createSecureDataAccess as f, cn as g, setAppConfig as h, getAppConfig as i, getCurrentAppName as j, getCurrentAppId as k, createBaseClient as l, logger as m, nameSchema as n, createLogger as o, phoneSchema as p, LogLevel as q, type LoggerConfig as r, sanitizeUserInput as s, formatDate as t, useSessionTracking as u, formatTime as v, formatDateTime as w, formatCurrency as x, formatNumber as y, formatPercent as z };