@jmruthers/pace-core 0.5.183 → 0.5.185

package/dist/timezone-_pgH8qrY.d.ts

@@ -0,0 +1,530 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { z } from 'zod';
+import { ClassValue } from 'clsx';
+
+/**
+ * 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 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 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: any[]): void;
+    /**
+     * Log info information (development only)
+     */
+    static info(component: string, message: string, ...args: any[]): void;
+    /**
+     * Log warning information (development only)
+     */
+    static warn(component: string, message: string, ...args: any[]): void;
+    /**
+     * Log error information (development only)
+     */
+    static error(component: string, message: string, ...args: any[]): void;
+    /**
+     * Create a scoped logger for a specific component
+     */
+    static createScopedLogger(component: string): {
+        debug: (message: string, ...args: any[]) => void;
+        info: (message: string, ...args: any[]) => void;
+        warn: (message: string, ...args: any[]) => void;
+        error: (message: string, ...args: any[]) => void;
+    };
+}
+/**
+ * Default logger instance for convenience
+ */
+declare const logger: {
+    debug: (component: string, message: string, ...args: any[]) => void;
+    info: (component: string, message: string, ...args: any[]) => void;
+    warn: (component: string, message: string, ...args: any[]) => void;
+    error: (component: string, message: string, ...args: any[]) => void;
+    createScopedLogger: (component: string) => {
+        debug: (message: string, ...args: any[]) => void;
+        info: (message: string, ...args: any[]) => void;
+        warn: (message: string, ...args: any[]) => void;
+        error: (message: string, ...args: any[]) => void;
+    };
+    configure: (config: Partial<LoggerConfig>) => void;
+};
+/**
+ * Convenience function to create a scoped logger
+ */
+declare function createLogger(component: string): {
+    debug: (message: string, ...args: any[]) => void;
+    info: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    error: (message: string, ...args: any[]) => 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.
+ *
+ * The third parameter can be either:
+ * - A number for fixed decimal places (backward compatible): `formatPercent(0.81, 'en-US', 2)`
+ * - An 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)
+ *
+ * @param value - The percentage value as a decimal (e.g., 0.81 for 0.81%)
+ * @param locale - The locale string (default: 'en-US')
+ * @param decimalsOrOptions - Either a number for fixed decimals, or an 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', 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, decimalsOrOptions?: number | {
+    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 { formatTimeInTimeZone as A, getUserTimeZone as B, toZonedTime as C, fromZonedTime as D, roundToNearestMinutes as E, getTimeZoneDifference as F, formatDateTimeForDisplay as G, formatDateOnlyForDisplay as H, formatDateTimeForTable as I, formatDateTimeForMap as J, type DateTimeFormatOptions as K, Logger as L, dateSchema as M, calculatePasswordStrength as N, type SecureDataAccess as S, urlSchema as a, passwordSchema as b, createSecureDataAccess as c, cn as d, emailSchema as e, getCurrentAppName as f, getAppConfig as g, getCurrentAppId as h, createLogger as i, LogLevel as j, type LoggerConfig as k, logger as l, formatDate as m, nameSchema as n, formatTime as o, phoneSchema as p, formatDateTime as q, formatCurrency as r, setAppConfig as s, formatNumber as t, useSessionTracking as u, formatPercent as v, formatCompactNumber as w, formatFileSize as x, formatInTimeZone as y, getTimezoneAbbreviation as z };

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

@@ -457,4 +457,4 @@ interface ExportOptions<TData extends DataRecord> {
     table: unknown;
 }
 
-export type { AggregateConfig as A, ChunkingConfig as C, DataRecord as D, ExportOptions as E, GetRowId as G, HierarchicalConfig as H, PerformanceConfig as P, ServerSideConfig as S, DataTableColumn as a, DataTableRBACConfig as b, DataTableFeatureConfig as c, PaginationMode as d, SearchIndexConfig as e, EmptyStateConfig as f, DataTableAction as g, ServerSideParams as h, ServerSideResponse as i, DataTableToolbarButton as j };
+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 };

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, b as FileCategory, a as FileMetadata, F 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-D06mEEWW.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-BjR39ktt.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-CBmg2950.js';

package/dist/types.js

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

package/dist/{usePublicRouteParams-JJczomYq.d.ts → usePublicRouteParams-CvnC3d-e.d.ts}

@@ -1,7 +1,118 @@
+import * as react_hook_form 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 { SupabaseClient } from '@supabase/supabase-js';
 import { D as Database } from './database.generated-CBmg2950.js';
-import { b as FileCategory, F as FileReference } from './file-reference-D06mEEWW.js';
+import { F as FileCategory, a as FileReference } from './file-reference-BjR39ktt.js';
+
+interface UseZodFormProps<T extends z.ZodTypeAny> {
+    schema: T;
+    defaultValues?: Partial<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>>;
+
+/**
+ * @file useFormDialog Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks
+ * @since 0.1.0
+ *
+ * Generic React hook for managing form dialog state (open/close, form data, reset behavior).
+ *
+ * @example
+ * ```ts
+ * interface ContactFormData {
+ *   name: string;
+ *   email: string;
+ * }
+ *
+ * function ContactDialog() {
+ *   const { isOpen, formData, openDialog, closeDialog, handleOpenChange } =
+ *     useFormDialog<ContactFormData>();
+ *
+ *   // Use in Dialog component
+ *   // <Dialog open={isOpen} onOpenChange={handleOpenChange}>...</Dialog>
+ * }
+ * ```
+ */
+/**
+ * Options for configuring the useFormDialog hook behavior
+ */
+interface UseFormDialogOptions<T = unknown> {
+    /**
+     * Callback invoked when the dialog open state changes
+     * @param open - The new open state
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Whether to reset form data when the dialog closes
+     * @default true
+     */
+    resetOnClose?: boolean;
+}
+/**
+ * Return type for the useFormDialog hook
+ */
+interface UseFormDialogReturn<T = unknown> {
+    /**
+     * Current open state of the dialog
+     */
+    isOpen: boolean;
+    /**
+     * Current form data (null when dialog is closed or no data provided)
+     */
+    formData: T | null;
+    /**
+     * Open the dialog with optional form data
+     * @param data - Optional form data to populate the dialog
+     */
+    openDialog: (data?: T | null) => void;
+    /**
+     * Close the dialog
+     */
+    closeDialog: () => void;
+    /**
+     * Handler for controlled dialog components (e.g., Radix UI Dialog)
+     * @param open - The new open state
+     */
+    handleOpenChange: (open: boolean) => void;
+}
+/**
+ * Generic React hook for managing form dialog state.
+ *
+ * Provides state management for form dialogs including:
+ * - Open/close state
+ * - Form data management
+ * - Automatic reset on close (configurable)
+ * - Controlled and uncontrolled usage patterns
+ *
+ * @param options - Configuration options for the hook
+ * @returns Object containing dialog state and control functions
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * const { isOpen, openDialog, closeDialog } = useFormDialog();
+ *
+ * // With form data
+ * interface UserData {
+ *   id: string;
+ *   name: string;
+ * }
+ * const { isOpen, formData, openDialog } = useFormDialog<UserData>();
+ *
+ * // Open with data
+ * openDialog({ id: '1', name: 'John' });
+ *
+ * // Controlled usage with callback
+ * const { handleOpenChange, isOpen } = useFormDialog({
+ *   onOpenChange: (open) => console.log('Dialog state:', open),
+ *   resetOnClose: false
+ * });
+ * ```
+ */
+declare function useFormDialog<T = unknown>({ onOpenChange, resetOnClose, }?: UseFormDialogOptions<T>): UseFormDialogReturn<T>;
 
 /**
  * @file useOrganisationPermissions Hook
@@ -734,4 +845,4 @@ declare function generatePublicRoutePath(eventCode: string, pageName?: string):
  */
 declare function extractEventCodeFromPath(path: string): string | null;
 
-export { type UsePublicEventLogoReturn as A, type UsePublicEventLogoOptions as B, type UsePublicRouteParamsReturn as C, type StorageConfig as D, type StorageFileMetadata as E, type FileSizeLimits as F, type StorageUrlOptions as G, 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, useAppConfig as g, type UseAppConfigReturn as h, usePublicEvent as i, clearPublicEventCache as j, getPublicEventCacheStats as k, usePublicFileDisplay as l, clearPublicFileDisplayCache as m, getPublicFileDisplayCacheStats as n, usePublicEventLogo as o, clearPublicLogoCache as p, getPublicLogoCacheStats as q, usePublicRouteParams as r, usePublicEventCode as s, generatePublicRoutePath as t, useEventTheme as u, extractEventCodeFromPath as v, type UsePublicEventReturn as w, type UsePublicEventOptions as x, type UsePublicFileDisplayReturn as y, type UsePublicFileDisplayOptions as z };
+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 };