@jmruthers/pace-core 0.6.8 → 0.6.10

package/dist/{usePublicRouteParams-MamNgwqe.d.ts → usePublicRouteParams-G3Ks53mk.d.ts}

@@ -1,13 +1,14 @@
 import * as react_hook_form from 'react-hook-form';
+import { DefaultValues } from 'react-hook-form';
 import { z } from 'zod';
-import { l as OrganisationRole, m as OrganisationPermission, S as SuperAdminContext, E as Event } from './event-CW5YB_2p.js';
+import { l as OrganisationRole, m as OrganisationPermission, S as SuperAdminContext, E as Event } from './event-WTAQuGcq.js';
 import { SupabaseClient } from '@supabase/supabase-js';
-import { D as Database } from './database.generated-CcnC_DRc.js';
+import { D as Database } from './database.generated-DT8JTZiP.js';
 import { F as FileCategory, a as FileReference } from './file-reference-BavO2eQj.js';
 
 interface UseZodFormProps<T extends z.ZodTypeAny> {
     schema: T;
-    defaultValues?: Partial<z.infer<T>>;
+    defaultValues?: DefaultValues<z.infer<T>>;
     mode?: 'onSubmit' | 'onBlur' | 'onChange' | 'onTouched' | 'all';
 }
 declare function useZodForm<T extends z.ZodTypeAny>({ schema, defaultValues, mode }: UseZodFormProps<T>): react_hook_form.UseFormReturn<z.TypeOf<T>, any, z.TypeOf<T>>;
@@ -39,7 +40,7 @@ declare function useZodForm<T extends z.ZodTypeAny>({ schema, defaultValues, mod
 /**
  * Options for configuring the useFormDialog hook behavior
  */
-interface UseFormDialogOptions<T = unknown> {
+interface UseFormDialogOptions {
     /**
      * Callback invoked when the dialog open state changes
      * @param open - The new open state
@@ -112,7 +113,7 @@ interface UseFormDialogReturn<T = unknown> {
  * });
  * ```
  */
-declare function useFormDialog<T = unknown>({ onOpenChange, resetOnClose, }?: UseFormDialogOptions<T>): UseFormDialogReturn<T>;
+declare function useFormDialog<T = unknown>({ onOpenChange, resetOnClose, }?: UseFormDialogOptions): UseFormDialogReturn<T>;
 
 /**
  * @file useOrganisationPermissions Hook
@@ -368,7 +369,7 @@ interface StorageUploadOptions {
     /** Optional custom path within the app/org/user structure */
     customPath?: string;
     /** Optional metadata to store with the file */
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 interface StorageFileMetadata {
     mimeType: string;
@@ -383,7 +384,7 @@ interface StorageFileMetadata {
     uploadedAt: string;
     tags?: string[];
     isPublic: boolean;
-    customMetadata?: Record<string, any>;
+    customMetadata?: Record<string, unknown>;
 }
 interface StorageUploadResult {
     success: boolean;

package/dist/utils.d.ts

@@ -1,134 +1,14 @@
-import { S as SanitizationOptions } from './timezone-BZe_eUxx.js';
-export { Q as DateTimeFormatOptions, q as LogLevel, L as Logger, r as LoggerConfig, K as SecureDataAccess, V as calculatePasswordStrength, g as cn, l as createBaseClient, o as createLogger, U as dateSchema, e as emailSchema, A as formatCompactNumber, x as formatCurrency, t as formatDate, N as formatDateOnlyForDisplay, w as formatDateTime, M as formatDateTimeForDisplay, P as formatDateTimeForMap, O as formatDateTimeForTable, B as formatFileSize, C as formatInTimeZone, y as formatNumber, z as formatPercent, v as formatTime, E as formatTimeInTimeZone, H as fromZonedTime, i as getAppConfig, k as getCurrentAppId, J as getTimeZoneDifference, D as getTimezoneAbbreviation, F as getUserTimeZone, m as logger, n as nameSchema, b as passwordSchema, p as phoneSchema, T as renderSafeHtml, I as roundToNearestMinutes, c as sanitizeFormData, d as sanitizeHtml, s as sanitizeUserInput, h as setAppConfig, G as toZonedTime, a as urlSchema, u as useSessionTracking, R as validateHtml } from './timezone-BZe_eUxx.js';
+import { S as SanitizationOptions } from './timezone-K-ptz3HO.js';
+export { U as DateTimeFormatOptions, q as LogLevel, L as Logger, r as LoggerConfig, O as SecureDataAccess, V as calculatePasswordStrength, g as cn, l as createBaseClient, o as createLogger, N as dateSchema, e as emailSchema, A as formatCompactNumber, x as formatCurrency, t as formatDate, Q as formatDateOnlyForDisplay, w as formatDateTime, P as formatDateTimeForDisplay, T as formatDateTimeForMap, R as formatDateTimeForTable, B as formatFileSize, C as formatInTimeZone, y as formatNumber, z as formatPercent, v as formatTime, E as formatTimeInTimeZone, H as fromZonedTime, i as getAppConfig, k as getCurrentAppId, J as getTimeZoneDifference, D as getTimezoneAbbreviation, F as getUserTimeZone, m as logger, n as nameSchema, b as passwordSchema, p as phoneSchema, M as renderSafeHtml, I as roundToNearestMinutes, c as sanitizeFormData, d as sanitizeHtml, s as sanitizeUserInput, h as setAppConfig, G as toZonedTime, a as urlSchema, u as useSessionTracking, K as validateHtml } from './timezone-K-ptz3HO.js';
 import { SupabaseClient } from '@supabase/supabase-js';
-import { D as Database } from './database.generated-CcnC_DRc.js';
-export { g as changePasswordSchema, t as combineSchemas, i as contactFormSchema, l as loginSchema, f as passwordResetSchema, q as pickSchema, r as registrationSchema, c as secureLoginSchema, s as securePasswordSchema, h as userProfileSchema } from './validation-643vUDZW.js';
+import { D as Database } from './database.generated-DT8JTZiP.js';
+export { g as changePasswordSchema, t as combineSchemas, i as contactFormSchema, l as loginSchema, f as passwordResetSchema, q as pickSchema, r as registrationSchema, c as secureLoginSchema, s as securePasswordSchema, h as userProfileSchema } from './validation-g5n0hDkh.js';
 import { z } from 'zod';
 export { u as useComponentPerformance } from './useComponentPerformance-DE9l5RkL.js';
 import * as date_fns from 'date-fns';
-import { D as DataTable } from './DataTable-DRUIgtUH.js';
-import { A as AutocompleteOptions, m as GooglePlaceAutocompletePrediction, P as ParsedAddress } from './types-DXstZpNI.js';
 import React__default, { ComponentType } from 'react';
+import { A as AutocompleteOptions, G as GooglePlaceAutocompletePrediction, P as ParsedAddress } from './types-Dr8sNhER.js';
 import 'clsx';
-import 'react/jsx-runtime';
-import '@tanstack/react-table';
-
-/**
- * @file Google Places API Utilities
- * @package @jmruthers/pace-core
- * @module Utils/GooglePlaces
- * @since 0.1.0
- *
- * Utility functions for interacting with Google Places API.
- * Uses the Google Maps JavaScript API to avoid CORS issues.
- *
- * Features:
- * - Places Autocomplete Service integration
- * - Places Service integration
- * - Address component parsing
- * - Error handling
- * - Request deduplication
- */
-
-/**
- * Fetch place autocomplete predictions using Google Maps JavaScript API
- *
- * @param query - Search query string
- * @param apiKey - Google Places API key
- * @param options - Optional autocomplete options
- * @returns Promise resolving to array of predictions
- *
- * @example
- * ```ts
- * const predictions = await fetchPlaceAutocomplete(
- *   '123 Main St',
- *   'your-api-key',
- *   { components: 'country:au' }
- * );
- * ```
- */
-declare function fetchPlaceAutocomplete(query: string, apiKey: string, options?: AutocompleteOptions): Promise<GooglePlaceAutocompletePrediction[]>;
-/**
- * Fetch place details from Google Places API
- *
- * @param placeId - Google Place ID
- * @param apiKey - Google Places API key
- * @returns Promise resolving to place details
- *
- * @example
- * ```ts
- * const place = await fetchPlaceDetails('ChIJ...', 'your-api-key');
- * ```
- */
-declare function fetchPlaceDetails(placeId: string, apiKey: string): Promise<{
-    place_id: string;
-    formatted_address?: string;
-    address_components?: Array<{
-        long_name: string;
-        short_name: string;
-        types: string[];
-    }>;
-    geometry?: {
-        location?: {
-            lat: () => number;
-            lng: () => number;
-        };
-    };
-}>;
-/**
- * Parse address components from Google Places API response
- *
- * @param components - Array of address components from Google API
- * @returns Parsed address components
- */
-declare function parseAddressComponents(components: Array<{
-    long_name: string;
-    short_name: string;
-    types: string[];
-}> | undefined): {
-    street_number: string | null;
-    route: string | null;
-    suburb: string | null;
-    state: string | null;
-    postcode: string | null;
-    country: string | null;
-};
-/**
- * Create parsed address from Google Places API place result
- *
- * @param place - Place result from Google Places Details API
- * @returns Parsed address matching core_address table structure
- */
-declare function createAddressFromPlaceResult(place: {
-    place_id: string;
-    formatted_address?: string;
-    address_components?: Array<{
-        long_name: string;
-        short_name: string;
-        types: string[];
-    }>;
-    geometry?: {
-        location?: {
-            lat: () => number;
-            lng: () => number;
-        };
-    };
-}): ParsedAddress;
-/**
- * Get full address details by place_id
- * Useful for retrieving address from stored place_id without autocomplete search
- *
- * @param placeId - Google Place ID
- * @param apiKey - Google Places API key
- * @returns Promise resolving to parsed address
- *
- * @example
- * ```ts
- * const address = await getAddressByPlaceId('ChIJ...', 'your-api-key');
- * // Returns: { place_id: 'ChIJ...', full_address: '...', ... }
- * ```
- */
-declare function getAddressByPlaceId(placeId: string, apiKey: string): Promise<ParsedAddress | null>;
 
 /**
  * @file Debug Logger Utility
@@ -139,6 +19,9 @@ declare function getAddressByPlaceId(placeId: string, apiKey: string): Promise<P
 /**
  * Debug logger that respects environment settings
  * Only logs in development mode to prevent production console spam
+ *
+ * NOTE: This utility intentionally uses console methods for debugging purposes.
+ * It provides a lightweight alternative to the main logger for development-only logging.
  */
 declare class DebugLogger {
     /**
@@ -148,19 +31,19 @@ declare class DebugLogger {
     /**
      * Log debug information only in development mode
      */
-    static log(component: string, message: string, ...args: any[]): void;
+    static log(component: string, message: string, ...args: unknown[]): void;
     /**
      * Log error information (always logged)
      */
-    static error(component: string, message: string, ...args: any[]): void;
+    static error(component: string, message: string, ...args: unknown[]): void;
     /**
      * Log warning information (always logged)
      */
-    static warn(component: string, message: string, ...args: any[]): void;
+    static warn(component: string, message: string, ...args: unknown[]): void;
     /**
      * Log info information only in development mode
      */
-    static info(component: string, message: string, ...args: any[]): void;
+    static info(component: string, message: string, ...args: unknown[]): void;
 }
 
 /**
@@ -253,6 +136,45 @@ declare class CachedAppIdResolver {
 }
 declare const cachedAppIdResolver: CachedAppIdResolver;
 
+/**
+ * @file App Icons Asset Map
+ * @package @jmruthers/pace-core
+ * @module Assets/AppIcons
+ * @since 0.6.0
+ *
+ * Centralized mapping of app icons bundled with pace-core.
+ * These icons are included in the package so consuming apps don't need to provide them.
+ */
+/**
+ * Map of app names (lowercase) to their icon URLs.
+ * Icons are imported as modules and will be bundled with the package.
+ */
+declare const appIcons: Record<string, string>;
+/**
+ * Get the icon URL for an app by its name.
+ *
+ * @param appName - The app name (e.g., 'CAKE', 'TRAC', 'CORE', 'pace-trac')
+ * @returns The icon URL if available, or undefined if not found
+ *
+ * @example
+ * ```ts
+ * const iconUrl = getAppIcon('CAKE'); // Returns bundled cake icon URL
+ * const iconUrl = getAppIcon('pace-trac'); // Returns bundled trac icon URL
+ * ```
+ */
+declare function getAppIcon(appName: string): string | undefined;
+/**
+ * Check if an app has a bundled icon available.
+ *
+ * @param appName - The app name to check
+ * @returns true if an icon is available, false otherwise
+ */
+declare function hasAppIcon(appName: string): boolean;
+/**
+ * List of all app names that have bundled icons.
+ */
+declare const appsWithIcons: string[];
+
 /**
  * @file Internal utilities for validation module
  * @internal This file contains implementation details that should not be used directly
@@ -480,7 +402,7 @@ declare function validateSecurityHeaders(headers: Record<string, string>): boole
 interface SecurityEvent {
     id?: string;
     action: string;
-    details: Record<string, any>;
+    details: Record<string, unknown>;
     timestamp?: number;
 }
 interface SecurityAlert {
@@ -649,13 +571,14 @@ interface LazyLoadOptions {
 /**
  * Create a lazy-loaded component with error boundary and loading fallback
  */
-declare function createLazyComponent<T extends ComponentType<any>>(importFn: () => Promise<{
+declare function createLazyComponent<T extends ComponentType<Record<string, unknown>>>(importFn: () => Promise<{
     default: T;
 }>, componentName: string, options?: LazyLoadOptions): T;
+
 /**
  * Lazy-loaded DataTable component
  */
-declare const LazyDataTable: typeof DataTable;
+declare const LazyDataTable: ComponentType<Record<string, unknown>>;
 
 /**
  * Permission utilities for transforming and managing permissions
@@ -781,7 +704,7 @@ declare function validateDeviceFingerprint(storedFingerprint: DeviceFingerprint,
  * @param organisationId - The organisation ID (unused)
  * @returns Promise that resolves immediately
  */
-declare function setOrganisationContext(supabase: SupabaseClient, organisationId: string): Promise<void>;
+declare function setOrganisationContext(_supabase: SupabaseClient, _organisationId: string): Promise<void>;
 /**
  * Clear organisation context from the database session
  *
@@ -805,7 +728,7 @@ declare function getOrganisationContext(supabase: SupabaseClient): Promise<strin
  * @param supabase - Supabase client instance (unused)
  * @returns Promise that resolves to false
  */
-declare function isOrganisationContextAvailable(supabase: SupabaseClient): Promise<boolean>;
+declare function isOrganisationContextAvailable(_supabase: SupabaseClient): Promise<boolean>;
 
 /**
  * @file Location Utilities
@@ -912,6 +835,246 @@ declare function areCoordinatesEqual(coords1: Coordinates | null | undefined, co
  */
 declare function getGoogleMapsUrl(coords?: Coordinates): string;
 
+/**
+ * @file Google Places API Utilities
+ * @package @jmruthers/pace-core
+ * @module Utils/GooglePlaces
+ * @since 0.1.0
+ *
+ * Utility functions for interacting with Google Places API.
+ * Uses the Google Maps JavaScript API to avoid CORS issues.
+ *
+ * Features:
+ * - Places Autocomplete Service integration
+ * - Places Service integration
+ * - Address component parsing
+ * - Error handling
+ * - Request deduplication
+ */
+
+/**
+ * Fetch place autocomplete predictions using Google Maps JavaScript API
+ *
+ * @param query - Search query string
+ * @param apiKey - Google Places API key
+ * @param options - Optional autocomplete options
+ * @returns Promise resolving to array of predictions
+ *
+ * @example
+ * ```ts
+ * const predictions = await fetchPlaceAutocomplete(
+ *   '123 Main St',
+ *   'your-api-key',
+ *   { components: 'country:au' }
+ * );
+ * ```
+ */
+declare function fetchPlaceAutocomplete(query: string, apiKey: string, options?: AutocompleteOptions): Promise<GooglePlaceAutocompletePrediction[]>;
+/**
+ * Fetch place details from Google Places API
+ *
+ * @param placeId - Google Place ID
+ * @param apiKey - Google Places API key
+ * @returns Promise resolving to place details
+ *
+ * @example
+ * ```ts
+ * const place = await fetchPlaceDetails('ChIJ...', 'your-api-key');
+ * ```
+ */
+declare function fetchPlaceDetails(placeId: string, apiKey: string): Promise<{
+    place_id: string;
+    formatted_address?: string;
+    address_components?: Array<{
+        long_name: string;
+        short_name: string;
+        types: string[];
+    }>;
+    geometry?: {
+        location?: {
+            lat: () => number;
+            lng: () => number;
+        };
+    };
+}>;
+/**
+ * Parse address components from Google Places API response
+ *
+ * @param components - Array of address components from Google API
+ * @returns Parsed address components
+ */
+declare function parseAddressComponents(components: Array<{
+    long_name: string;
+    short_name: string;
+    types: string[];
+}> | undefined): {
+    street_number: string | null;
+    route: string | null;
+    suburb: string | null;
+    state: string | null;
+    postcode: string | null;
+    country: string | null;
+};
+/**
+ * Create parsed address from Google Places API place result
+ *
+ * @param place - Place result from Google Places Details API
+ * @returns Parsed address matching core_address table structure
+ */
+declare function createAddressFromPlaceResult(place: {
+    place_id: string;
+    formatted_address?: string;
+    address_components?: Array<{
+        long_name: string;
+        short_name: string;
+        types: string[];
+    }>;
+    geometry?: {
+        location?: {
+            lat: () => number;
+            lng: () => number;
+        };
+    };
+}): ParsedAddress;
+/**
+ * Get full address details by place_id
+ * Useful for retrieving address from stored place_id without autocomplete search
+ *
+ * @param placeId - Google Place ID
+ * @param apiKey - Google Places API key
+ * @returns Promise resolving to parsed address
+ *
+ * @example
+ * ```ts
+ * const address = await getAddressByPlaceId('ChIJ...', 'your-api-key');
+ * // Returns: { place_id: 'ChIJ...', full_address: '...', ... }
+ * ```
+ */
+declare function getAddressByPlaceId(placeId: string, apiKey: string): Promise<ParsedAddress | null>;
+
+/**
+ * @file Google Maps Script Loader
+ * @package @jmruthers/pace-core
+ * @module Utils/GooglePlaces
+ * @since 0.1.0
+ *
+ * Utility to dynamically load the Google Maps JavaScript API.
+ * This is required because the REST API doesn't support CORS from browsers.
+ */
+declare global {
+    interface Window {
+        google?: {
+            maps: {
+                places: {
+                    AutocompleteSuggestion: {
+                        fetchAutocompleteSuggestions: (request: {
+                            input: string;
+                            includedRegionCodes?: string[];
+                            locationBias?: {
+                                circle?: {
+                                    center: {
+                                        latitude: number;
+                                        longitude: number;
+                                    };
+                                    radius: number;
+                                };
+                            };
+                            includedPrimaryTypes?: string[];
+                            languageCode?: string;
+                        }) => Promise<{
+                            suggestions: Array<{
+                                placePrediction?: {
+                                    placeId: string;
+                                    text: {
+                                        text: string;
+                                        matches: Array<{
+                                            endOffset: number;
+                                            startOffset: number;
+                                        }>;
+                                    };
+                                    structuredFormat?: {
+                                        mainText: {
+                                            text: string;
+                                        };
+                                        secondaryText: {
+                                            text: string;
+                                        };
+                                    };
+                                };
+                            }>;
+                        }>;
+                    };
+                    AutocompleteService: new () => {
+                        getPlacePredictions: (request: {
+                            input: string;
+                            componentRestrictions?: {
+                                country: string | string[];
+                            };
+                            location?: {
+                                lat: () => number;
+                                lng: () => number;
+                            };
+                            radius?: number;
+                            types?: string[];
+                            language?: string;
+                        }, callback: (predictions: Array<{
+                            description: string;
+                            place_id: string;
+                            structured_formatting: {
+                                main_text: string;
+                                secondary_text: string;
+                            };
+                        }> | null, status: string) => void) => void;
+                    };
+                    PlacesService: new (element: HTMLElement) => {
+                        getDetails: (request: {
+                            placeId: string;
+                            fields?: string[];
+                        }, callback: (place: {
+                            place_id: string;
+                            formatted_address?: string;
+                            address_components?: Array<{
+                                long_name: string;
+                                short_name: string;
+                                types: string[];
+                            }>;
+                            geometry?: {
+                                location?: {
+                                    lat: () => number;
+                                    lng: () => number;
+                                };
+                            };
+                        } | null, status: string) => void) => void;
+                    };
+                    PlacesServiceStatus: {
+                        OK: string;
+                        ZERO_RESULTS: string;
+                        NOT_FOUND: string;
+                        REQUEST_DENIED: string;
+                        INVALID_REQUEST: string;
+                        OVER_QUERY_LIMIT: string;
+                    };
+                };
+                LatLng: new (lat: number, lng: number) => {
+                    lat: () => number;
+                    lng: () => number;
+                };
+            };
+        };
+    }
+}
+/**
+ * Load Google Maps JavaScript API script
+ * @param apiKey - Google Places API key
+ * @param libraries - Comma-separated list of libraries to load (default: 'places')
+ * @returns Promise that resolves when the script is loaded
+ */
+declare function loadGoogleMapsScript(apiKey: string, libraries?: string): Promise<void>;
+/**
+ * Check if Google Maps is already loaded
+ */
+declare function isGoogleMapsLoaded(): boolean;
+
 /**
  * Request Deduplication Utility
  * @package @jmruthers/pace-core
@@ -922,6 +1085,7 @@ declare function getGoogleMapsUrl(coords?: Coordinates): string;
  * When multiple components request the same data simultaneously, only one
  * request is made and all callers share the same promise.
  */
+
 /**
  * Generate a request key from request parameters
  *
@@ -931,7 +1095,7 @@ declare function getGoogleMapsUrl(coords?: Coordinates): string;
  * @param select - Select columns
  * @returns Request key string
  */
-declare function generateRequestKey(method: string, table: string, filters?: Record<string, any>, select?: string): string;
+declare function generateRequestKey(method: string, table: string, filters?: Record<string, unknown>, select?: string): string;
 /**
  * Get or create a request
  *
@@ -1003,6 +1167,6 @@ declare function getInFlightRequestStats(): {
  * );
  * ```
  */
-declare function deduplicatedQuery<T>(supabase: any, table: string, filters: Record<string, any>, select: string, requestFn: () => Promise<T>): Promise<T>;
+declare function deduplicatedQuery<T>(supabase: SupabaseClient<Database>, table: string, filters: Record<string, unknown>, select: string, requestFn: () => Promise<T>): Promise<T>;
 
-export { AutocompleteOptions, type CSRFTokenData, CachedAppIdResolver, type Coordinates, DebugLogger, GooglePlaceAutocompletePrediction, LazyDataTable, PERFORMANCE_BUDGETS, PERFORMANCE_THRESHOLDS, ParsedAddress, type PerformanceMetrics$1 as PerformanceMetrics, PermissionType, type SafeQueryParams, SanitizationOptions, type SecurityEvent$1 as SecurityEvent, areCoordinatesEqual, auditLogger, buildSafeQueryParams, bundleAnalyzer, cachedAppIdResolver, clearInFlightRequests, clearOrganisationContext, createAddressFromPlaceResult, createLazyComponent, createLazyUtility, createPerformanceBenchmark, csrfManager, deduplicatedQuery, deepMerge, detectSQLInjection, escapeLikeQuery, fetchPlaceAutocomplete, fetchPlaceDetails, formatCoordinates, generateCSRFToken, generateDeviceFingerprint, generateRequestKey, getAddressByPlaceId, getAppId, getAppIds, getAppNameFromBuildTime, getAppNameFromEnvironment, getAppNameFromGlobal, getAppNameFromPackageJson, getCSRFToken, getCurrentAppName, getCurrentAppNameWithFallback, getGoogleMapsUrl, getInFlightRequestStats, getOrCreateRequest, getOrganisationContext, getSecurityHeaders, hasAllPermissions, hasAnyPermission, hasPermission, hasValidCoordinates, isEmpty, isObject, isOrganisationContextAvailable, isStrongPassword, isValidDate, isValidEmail, isValidUrl, isWithinRange, lazyCSVUtils, lazyChartUtils, lazyDateUtils, lazyFormUtils, lazyLodash, limitOffsetSchema, loadCSVUtils, loadChartUtils, loadDateUtils, loadFormUtils, loadLodash, logAuditEvent, logAuthEvent, logPermissionEvent, logSecurityEvent, matchesPattern, measureRenderPerformance, orderBySchema, parseAddressComponents, parsePermission, performanceBudgetMonitor, sanitizeFilters, sanitizeSearchQuery, searchQuerySchema, securityMonitor, setOrganisationContext, setRBACAppName, sqlIdentifierSchema, trackDynamicImport, transformPermissionMapToBoolean, userPreferencesSchema, userSettingsSchema, usernameSchema, validateCSRFToken, validateDeviceFingerprint, validateImportPattern, validateSecurityHeaders, validateUserInput };
+export { AutocompleteOptions, type CSRFTokenData, CachedAppIdResolver, type Coordinates, DebugLogger, GooglePlaceAutocompletePrediction, LazyDataTable, PERFORMANCE_BUDGETS, PERFORMANCE_THRESHOLDS, ParsedAddress, type PerformanceMetrics$1 as PerformanceMetrics, PermissionType, type SafeQueryParams, SanitizationOptions, type SecurityEvent$1 as SecurityEvent, appIcons, appsWithIcons, areCoordinatesEqual, auditLogger, buildSafeQueryParams, bundleAnalyzer, cachedAppIdResolver, clearInFlightRequests, clearOrganisationContext, createAddressFromPlaceResult, createLazyComponent, createLazyUtility, createPerformanceBenchmark, csrfManager, deduplicatedQuery, deepMerge, detectSQLInjection, escapeLikeQuery, fetchPlaceAutocomplete, fetchPlaceDetails, formatCoordinates, generateCSRFToken, generateDeviceFingerprint, generateRequestKey, getAddressByPlaceId, getAppIcon, getAppId, getAppIds, getAppNameFromBuildTime, getAppNameFromEnvironment, getAppNameFromGlobal, getAppNameFromPackageJson, getCSRFToken, getCurrentAppName, getCurrentAppNameWithFallback, getGoogleMapsUrl, getInFlightRequestStats, getOrCreateRequest, getOrganisationContext, getSecurityHeaders, hasAllPermissions, hasAnyPermission, hasAppIcon, hasPermission, hasValidCoordinates, isEmpty, isGoogleMapsLoaded, isObject, isOrganisationContextAvailable, isStrongPassword, isValidDate, isValidEmail, isValidUrl, isWithinRange, lazyCSVUtils, lazyChartUtils, lazyDateUtils, lazyFormUtils, lazyLodash, limitOffsetSchema, loadCSVUtils, loadChartUtils, loadDateUtils, loadFormUtils, loadGoogleMapsScript, loadLodash, logAuditEvent, logAuthEvent, logPermissionEvent, logSecurityEvent, matchesPattern, measureRenderPerformance, orderBySchema, parseAddressComponents, parsePermission, performanceBudgetMonitor, sanitizeFilters, sanitizeSearchQuery, searchQuerySchema, securityMonitor, setOrganisationContext, setRBACAppName, sqlIdentifierSchema, trackDynamicImport, transformPermissionMapToBoolean, userPreferencesSchema, userSettingsSchema, usernameSchema, validateCSRFToken, validateDeviceFingerprint, validateImportPattern, validateSecurityHeaders, validateUserInput };