@jmruthers/pace-core 0.5.186 → 0.5.187

package/dist/{types-DUyCRSTj.d.ts → types-Bwgl--Xo.d.ts}

@@ -1,6 +1,167 @@
 import React__default from 'react';
 import { ColumnDef, SortingState, ColumnFiltersState, GroupingState } from '@tanstack/react-table';
 
+/**
+ * @file Google Places API Types
+ * @package @jmruthers/pace-core
+ * @module Utils/GooglePlaces
+ * @since 0.1.0
+ */
+/**
+ * Google Places Autocomplete API response prediction
+ */
+interface GooglePlaceAutocompletePrediction {
+    description: string;
+    place_id: string;
+    structured_formatting?: {
+        main_text: string;
+        secondary_text: string;
+    };
+    types?: string[];
+}
+/**
+ * Parsed address matching pace_address table structure
+ */
+interface ParsedAddress {
+    place_id: string;
+    full_address: string | null;
+    street_number: string | null;
+    route: string | null;
+    suburb: string | null;
+    state: string | null;
+    postcode: string | null;
+    country: string | null;
+    lat: number | null;
+    lng: number | null;
+}
+/**
+ * Options for Google Places Autocomplete API
+ */
+interface AutocompleteOptions {
+    /** Restrict results to specific countries (ISO 3166-1 Alpha-2 country codes) */
+    components?: string;
+    /** Location bias (lat,lng) */
+    location?: string;
+    /** Radius in meters for location bias */
+    radius?: number;
+    /** Restrict results to specific place types */
+    types?: string;
+    /** Language code for results */
+    language?: string;
+}
+
+/**
+ * @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;
+                };
+            };
+        };
+    }
+}
+
 /**
  * @file DataTable Type Definitions
  * @package @jmruthers/pace-core
@@ -457,4 +618,4 @@ interface ExportOptions<TData extends DataRecord> {
     table: unknown;
 }
 
-export type { AggregateConfig as A, ChunkingConfig as C, DataTableColumn as D, EmptyStateConfig as E, GetRowId as G, HierarchicalConfig as H, PerformanceConfig as P, ServerSideConfig as S, DataTableAction as a, DataTableToolbarButton as b, DataRecord as c, DataTableRBACConfig as d, DataTableFeatureConfig as e, PaginationMode as f, SearchIndexConfig as g, ExportOptions as h, ServerSideParams as i, ServerSideResponse as j };
+export type { AutocompleteOptions as A, ChunkingConfig as C, DataTableColumn as D, EmptyStateConfig as E, GetRowId as G, HierarchicalConfig as H, ParsedAddress as P, ServerSideConfig as S, DataTableAction as a, DataTableToolbarButton as b, AggregateConfig as c, DataRecord as d, DataTableRBACConfig as e, DataTableFeatureConfig as f, PerformanceConfig as g, PaginationMode as h, SearchIndexConfig as i, ExportOptions as j, ServerSideParams as k, ServerSideResponse as l, GooglePlaceAutocompletePrediction as m };

package/dist/types.d.ts

@@ -3,7 +3,7 @@ export { A as AppId, D as DataRecord, E as EventId, O as OrganisationId, P as Pa
 import { U as User, a as Session } from './auth-BZOJqrdd.js';
 export { S as SessionRestorationState } from './auth-BZOJqrdd.js';
 export { E as Event, c as EventContextType, b as EventTheme, k as ORGANISATION_ROLE_PERMISSIONS, O as Organisation, n as OrganisationAccessLog, h as OrganisationContextType, j as OrganisationHierarchy, e as OrganisationInvitation, a as OrganisationMembership, m as OrganisationPermission, i as OrganisationProviderProps, l as OrganisationRole, f as OrganisationRoleDefinition, g as OrganisationSecurityError, d as OrganisationSettings, o as SecureQueryOptions, S as SuperAdminContext, T as ThemeColors, U as UserProfile } from './event-CW5YB_2p.js';
-export { g as BucketInfo, B as BulkUploadResult, F as FileCategory, b as FileMetadata, a as FileReference, d as FileReferenceService, f as FileReferenceWithUrl, c as FileUploadOptions, e as FileUploadResult, h as FileUrlInfo, S as StorageUploadOptions, U as UploadProgress } from './file-reference-PRTSLxKx.js';
+export { g as BucketInfo, B as BulkUploadResult, F as FileCategory, b as FileMetadata, a as FileReference, d as FileReferenceService, f as FileReferenceWithUrl, c as FileUploadOptions, e as FileUploadResult, h as FileUrlInfo, S as StorageUploadOptions, U as UploadProgress } from './file-reference-D037xOFK.js';
 export { C as ChangePasswordFormValues, o as ContactFormData, F as FormData, k as LoginFormData, L as LoginFormValues, P as ProfileFormData, m as RegistrationFormData, R as RegistrationFormValues, S as SecureLoginFormValues, j as SecureRegistrationFormValues, U as UserProfileFormValues, V as ValidationError, a as ValidationResult, g as changePasswordSchema, t as combineSchemas, i as contactFormSchema, d as dateSchema, e as emailSchema, l as loginSchema, n as nameSchema, f as passwordResetSchema, b as passwordSchema, p as phoneSchema, q as pickSchema, r as registrationSchema, c as secureLoginSchema, s as securePasswordSchema, u as urlSchema, h as userProfileSchema } from './validation-643vUDZW.js';
 import { SupabaseClient } from '@supabase/supabase-js';
 export { D as Database, J as Json } from './database.generated-DI89OQeI.js';

package/dist/types.js

@@ -1,6 +1,6 @@
 import {
   FileCategory
-} from "./chunk-UQWSHFVX.js";
+} from "./chunk-SAUPYVLF.js";
 import {
   AuthErrorCode,
   PermissionErrorCode,

package/dist/{usePublicRouteParams-D71QLlg4.d.ts → usePublicRouteParams-CTDELQ7H.d.ts}

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import { l as OrganisationRole, m as OrganisationPermission, S as SuperAdminContext, E as Event } from './event-CW5YB_2p.js';
 import { SupabaseClient } from '@supabase/supabase-js';
 import { D as Database } from './database.generated-DI89OQeI.js';
-import { F as FileCategory, a as FileReference } from './file-reference-PRTSLxKx.js';
+import { F as FileCategory, a as FileReference } from './file-reference-D037xOFK.js';
 
 interface UseZodFormProps<T extends z.ZodTypeAny> {
     schema: T;
@@ -845,4 +845,4 @@ declare function generatePublicRoutePath(eventCode: string, pageName?: string):
  */
 declare function extractEventCodeFromPath(path: string): string | null;
 
-export { type UsePublicEventReturn as A, type UsePublicEventOptions as B, type UsePublicFileDisplayReturn as C, type UsePublicFileDisplayOptions as D, type UsePublicEventLogoReturn as E, type UsePublicEventLogoOptions as F, type UsePublicRouteParamsReturn as G, type FileSizeLimits as H, type StorageConfig as I, type StorageFileMetadata as J, type StorageUrlOptions as K, type OrganisationSecurityHook as O, type StorageUploadOptions as S, type UseOrganisationPermissionsReturn as U, type StorageUploadResult as a, type StorageListOptions as b, type StorageListResult as c, type StorageFileInfo as d, useOrganisationPermissions as e, useOrganisationSecurity as f, useZodForm as g, useFormDialog as h, type UseFormDialogOptions as i, type UseFormDialogReturn as j, useAppConfig as k, type UseAppConfigReturn as l, usePublicEvent as m, clearPublicEventCache as n, getPublicEventCacheStats as o, usePublicFileDisplay as p, clearPublicFileDisplayCache as q, getPublicFileDisplayCacheStats as r, usePublicEventLogo as s, clearPublicLogoCache as t, useEventTheme as u, getPublicLogoCacheStats as v, usePublicRouteParams as w, usePublicEventCode as x, generatePublicRoutePath as y, extractEventCodeFromPath as z };
+export { extractEventCodeFromPath as A, type UsePublicEventReturn as B, type UsePublicEventOptions as C, type UsePublicFileDisplayReturn as D, type UsePublicFileDisplayOptions as E, type FileSizeLimits as F, type UsePublicEventLogoReturn as G, type UsePublicEventLogoOptions as H, type UsePublicRouteParamsReturn as I, type UseOrganisationPermissionsReturn as J, type UseAppConfigReturn as K, type OrganisationSecurityHook as O, type StorageConfig as S, type UseFormDialogOptions as U, type StorageUploadOptions as a, type StorageFileMetadata as b, type StorageUploadResult as c, type StorageUrlOptions as d, type StorageListOptions as e, type StorageListResult as f, useFormDialog as g, type UseFormDialogReturn as h, useOrganisationPermissions as i, useOrganisationSecurity as j, useAppConfig as k, useEventTheme as l, type StorageFileInfo as m, usePublicEvent as n, clearPublicEventCache as o, getPublicEventCacheStats as p, usePublicFileDisplay as q, clearPublicFileDisplayCache as r, getPublicFileDisplayCacheStats as s, usePublicEventLogo as t, useZodForm as u, clearPublicLogoCache as v, getPublicLogoCacheStats as w, usePublicRouteParams as x, usePublicEventCode as y, generatePublicRoutePath as z };

package/dist/utils.d.ts

@@ -5,13 +5,130 @@ export { g as changePasswordSchema, t as combineSchemas, i as contactFormSchema,
 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-Z9NLVJh0.js';
-import './types-DUyCRSTj.js';
+import { D as DataTable } from './DataTable-IVYljGJ6.js';
+import { A as AutocompleteOptions, m as GooglePlaceAutocompletePrediction, P as ParsedAddress } from './types-Bwgl--Xo.js';
 import React__default, { ComponentType } from 'react';
 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 pace_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
  * @package @jmruthers/pace-core
@@ -889,4 +1006,97 @@ declare function areCoordinatesEqual(coords1: Coordinates | null | undefined, co
  */
 declare function getGoogleMapsUrl(coords?: Coordinates): string;
 
-export { type CSRFTokenData, CachedAppIdResolver, type Coordinates, DebugLogger, LazyDataTable, PERFORMANCE_BUDGETS, PERFORMANCE_THRESHOLDS, type PerformanceMetrics$1 as PerformanceMetrics, PermissionType, type SafeQueryParams, type SanitizationOptions, type SecurityEvent$1 as SecurityEvent, areCoordinatesEqual, auditLog, auditLogger, buildSafeQueryParams, bundleAnalyzer, cachedAppIdResolver, clearOrganisationContext, createLazyComponent, createLazyUtility, createPerformanceBenchmark, csrfManager, deepMerge, detectSQLInjection, escapeLikeQuery, formatCoordinates, generateCSRFToken, generateDeviceFingerprint, getAppId, getAppIds, getAppNameFromBuildTime, getAppNameFromEnvironment, getAppNameFromGlobal, getAppNameFromPackageJson, getCSRFToken, getCurrentAppName, getCurrentAppNameWithFallback, getGoogleMapsUrl, 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, parsePermission, performanceBudgetMonitor, renderSafeHtml, sanitizeFilters, sanitizeFormData, sanitizeHtml, sanitizeSearchQuery, sanitizeUserInput, searchQuerySchema, securityMonitor, setOrganisationContext, setRBACAppName, sqlIdentifierSchema, trackDynamicImport, transformPermissionMapToBoolean, userPreferencesSchema, userSettingsSchema, usernameSchema, validateCSRFToken, validateDeviceFingerprint, validateHtml, validateImportPattern, validateSecurityHeaders, validateUserInput };
+/**
+ * Request Deduplication Utility
+ * @package @jmruthers/pace-core
+ * @module Utils/RequestDeduplication
+ * @since 2.0.0
+ *
+ * Provides request deduplication to prevent duplicate in-flight requests.
+ * 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
+ *
+ * @param method - HTTP method (GET, POST, etc.)
+ * @param table - Table name
+ * @param filters - Filter object
+ * @param select - Select columns
+ * @returns Request key string
+ */
+declare function generateRequestKey(method: string, table: string, filters?: Record<string, any>, select?: string): string;
+/**
+ * Get or create a request
+ *
+ * If a request with the same key is already in-flight, returns the existing promise.
+ * Otherwise, creates a new request and stores it for deduplication.
+ *
+ * @param key - Request key
+ * @param requestFn - Function that performs the actual request
+ * @returns Promise that resolves to the request result
+ *
+ * @example
+ * ```ts
+ * const data = await getOrCreateRequest(
+ *   'GET:pace_person:{"user_id":"123"}',
+ *   async () => {
+ *     const { data } = await supabase
+ *       .from('pace_person')
+ *       .select('id, first_name')
+ *       .eq('user_id', '123')
+ *       .single();
+ *     return data;
+ *   }
+ * );
+ * ```
+ */
+declare function getOrCreateRequest<T>(key: string, requestFn: () => Promise<T>): Promise<T>;
+/**
+ * Clear all in-flight requests
+ *
+ * Useful for cleanup or testing.
+ */
+declare function clearInFlightRequests(): void;
+/**
+ * Get statistics about in-flight requests
+ *
+ * @returns Statistics object
+ */
+declare function getInFlightRequestStats(): {
+    count: number;
+    keys: string[];
+};
+/**
+ * Supabase query wrapper with automatic deduplication
+ *
+ * Wraps a Supabase query to automatically deduplicate identical requests.
+ *
+ * @param supabase - Supabase client
+ * @param table - Table name
+ * @param filters - Filter object (e.g., { user_id: '123' })
+ * @param select - Select columns (default: '*')
+ * @param requestFn - Function that performs the query
+ * @returns Promise that resolves to query result
+ *
+ * @example
+ * ```ts
+ * const person = await deduplicatedQuery(
+ *   supabase,
+ *   'pace_person',
+ *   { user_id: userId },
+ *   'id, first_name, last_name',
+ *   async () => {
+ *     const { data } = await supabase
+ *       .from('pace_person')
+ *       .select('id, first_name, last_name')
+ *       .eq('user_id', userId)
+ *       .single();
+ *     return data;
+ *   }
+ * );
+ * ```
+ */
+declare function deduplicatedQuery<T>(supabase: any, table: string, filters: Record<string, any>, 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, type SanitizationOptions, type SecurityEvent$1 as SecurityEvent, areCoordinatesEqual, auditLog, 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, renderSafeHtml, sanitizeFilters, sanitizeFormData, sanitizeHtml, sanitizeSearchQuery, sanitizeUserInput, searchQuerySchema, securityMonitor, setOrganisationContext, setRBACAppName, sqlIdentifierSchema, trackDynamicImport, transformPermissionMapToBoolean, userPreferencesSchema, userSettingsSchema, usernameSchema, validateCSRFToken, validateDeviceFingerprint, validateHtml, validateImportPattern, validateSecurityHeaders, validateUserInput };

package/dist/utils.js

@@ -58,8 +58,18 @@ import {
 } from "./chunk-E66EQZE6.js";
 import {
   PERFORMANCE_BUDGETS,
+  clearInFlightRequests,
+  createAddressFromPlaceResult,
+  deduplicatedQuery,
+  fetchPlaceAutocomplete,
+  fetchPlaceDetails,
+  generateRequestKey,
+  getAddressByPlaceId,
+  getInFlightRequestStats,
+  getOrCreateRequest,
+  parseAddressComponents,
   performanceBudgetMonitor
-} from "./chunk-FMUCXFII.js";
+} from "./chunk-YHCN776L.js";
 import {
   clearOrganisationContext,
   getOrganisationContext,
@@ -941,7 +951,7 @@ function createLazyComponent(importFn, componentName, options = {}) {
   return WrappedComponent;
 }
 var LazyDataTable = createLazyComponent(
-  () => import("./DataTable-IX2NBUTP.js").then((module) => ({ default: module.DataTable })),
+  () => import("./DataTable-K3RJRSOX.js").then((module) => ({ default: module.DataTable })),
   "DataTable"
 );
 
@@ -1271,20 +1281,25 @@ export {
   cachedAppIdResolver,
   calculatePasswordStrength,
   changePasswordSchema,
+  clearInFlightRequests,
   clearOrganisationContext,
   cn,
   combineSchemas,
   contactFormSchema,
+  createAddressFromPlaceResult,
   createLazyComponent,
   createLazyUtility,
   createLogger,
   createPerformanceBenchmark,
   csrfManager,
   dateSchema,
+  deduplicatedQuery,
   deepMerge,
   detectSQLInjection,
   emailSchema,
   escapeLikeQuery,
+  fetchPlaceAutocomplete,
+  fetchPlaceDetails,
   formatCompactNumber,
   formatCoordinates,
   formatCurrency,
@@ -1303,6 +1318,8 @@ export {
   fromZonedTime,
   generateCSRFToken,
   generateDeviceFingerprint,
+  generateRequestKey,
+  getAddressByPlaceId,
   getAppConfig,
   getAppId,
   getAppIds,
@@ -1315,6 +1332,8 @@ export {
   getCurrentAppName,
   getCurrentAppNameWithFallback,
   getGoogleMapsUrl,
+  getInFlightRequestStats,
+  getOrCreateRequest,
   getOrganisationContext,
   getSecurityHeaders,
   getTimeZoneDifference,
@@ -1353,6 +1372,7 @@ export {
   measureRenderPerformance,
   nameSchema,
   orderBySchema,
+  parseAddressComponents,
   parsePermission,
   passwordResetSchema,
   passwordSchema,