@jmruthers/pace-core 0.4.1 → 0.5.1

package/dist/{Table-CIm9IWqk.d.ts → PublicLoadingSpinner-DztrzuJr.d.ts}

@@ -1,19 +1,18 @@
 import * as React from 'react';
-import React__default, { Component, ReactNode } from 'react';
+import React__default, { Component, ReactNode, ErrorInfo } from 'react';
 import * as LabelPrimitive from '@radix-ui/react-label';
 import * as AvatarPrimitive from '@radix-ui/react-avatar';
 import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
 import * as ProgressPrimitive from '@radix-ui/react-progress';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as DialogPrimitive from '@radix-ui/react-dialog';
-import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
 import * as ToastPrimitives from '@radix-ui/react-toast';
 import * as TooltipPrimitive from '@radix-ui/react-tooltip';
 import { FieldValues, DefaultValues, SubmitHandler, SubmitErrorHandler, UseFormReturn } from 'react-hook-form';
 import { z } from 'zod';
-import { User } from '@supabase/supabase-js';
-import { r as Event } from './unified-BtRpPbmp.js';
-import { O as Organisation } from './organisation-DLNNQhPB.js';
+import { User, SupabaseClient, createClient } from '@supabase/supabase-js';
+import { r as Event } from './unified-CM7T0aTK.js';
+import { O as Organisation } from './organisation-CO3Sh3_D.js';
 
 interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
     /** Visual variant of the button */
@@ -57,7 +56,7 @@ declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAtt
  * Features:
  * - Semantic HTML structure (article, header, main, footer, etc.)
  * - Modular card structure (header, content, footer, actions, etc.)
- * - CardContent uses div element for primary content (accessible when nested)
+ * - CardContent uses main element for primary content (accessible when nested)
  * - Consistent padding, border, and shadow
  * - Responsive and accessible
  * - HoverCard for popover-style cards
@@ -86,7 +85,7 @@ declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAtt
  * // Semantic HTML structure:
  * // - Card: <article> element for self-contained content
  * // - CardHeader: <header> element for card heading area
- * // - CardContent: <div> element for primary card content
+ * // - CardContent: <main> element for primary card content
  * // - CardFooter: <footer> element for card footer area
  * // - CardActions: <nav> element for action buttons
  *
@@ -117,9 +116,9 @@ declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttribu
 declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLElement> & React.RefAttributes<HTMLElement>>;
 declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
 declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
-declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLElement> & React.RefAttributes<HTMLElement>>;
 declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLElement> & React.RefAttributes<HTMLElement>>;
-declare const CardActions: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLElement> & React.RefAttributes<HTMLElement>>;
+declare const CardActions: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
 type CardActionsProps = React.HTMLAttributes<HTMLElement>;
 
 /**
@@ -497,7 +496,7 @@ declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.C
  * // Progress with custom styling
  * <Progress
  *   value={75}
- *   className="h-4 bg-app-sec-200"
+ *   className="h-4 bg-sec-200"
  * />
  *
  * // Animated progress (controlled)
@@ -559,7 +558,7 @@ declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.Re
  * Dialog size variants
  * @public
  */
-type DialogSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+type DialogSize = 'sm' | 'md' | 'lg' | 'xl' | 'full' | 'auto';
 /**
  * Props for the Dialog root component
  * @public
@@ -632,18 +631,34 @@ interface DialogFooterProps extends React.HTMLAttributes<HTMLElement> {
 interface DialogBodyProps extends React.HTMLAttributes<HTMLElement> {
     /** Custom max height for the scrollable area */
     maxHeight?: string;
+    /** HTML content to render (will be sanitized for security) */
+    htmlContent?: string;
+    /** Whether to allow HTML content rendering (default: true) */
+    allowHtml?: boolean;
+    /** Whether to use strict HTML sanitization (default: true) */
+    strictSanitization?: boolean;
+    /** Whether to log HTML sanitization warnings to console (default: false) */
+    logWarnings?: boolean;
 }
 /**
  * Props for the DialogTitle component
  * @public
  */
 interface DialogTitleProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Title> {
+    /** HTML content to render as title (will be sanitized for security) */
+    htmlContent?: string;
+    /** Whether to allow HTML content rendering (default: true) */
+    allowHtml?: boolean;
 }
 /**
  * Props for the DialogDescription component
  * @public
  */
 interface DialogDescriptionProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Description> {
+    /** HTML content to render as description (will be sanitized for security) */
+    htmlContent?: string;
+    /** Whether to allow HTML content rendering (default: true) */
+    allowHtml?: boolean;
 }
 declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
 declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
@@ -698,22 +713,30 @@ declare const DialogHeader: {
 /**
  * DialogBody component
  * Semantic main content area for dialog body content with scrollable functionality
+ * Supports both React children and safe HTML content rendering
  *
  * @param props - Body configuration and styling
  * @returns JSX.Element - The scrollable dialog body container using semantic <main> element
  *
  * @example
  * ```tsx
+ * // Using React children
  * <DialogBody>
  *   <section className="space-y-4">
  *     <h4>Content Title</h4>
  *     <p>Long content that will scroll...</p>
  *   </section>
  * </DialogBody>
+ *
+ * // Using HTML content
+ * <DialogBody
+ *   htmlContent="<h2>Import Instructions</h2><p>Upload a CSV file with the following format:</p><ul><li>Required columns: name, email</li><li>Optional columns: phone, address</li></ul>"
+ *   allowHtml={true}
+ * />
  * ```
  */
 declare const DialogBody: {
-    ({ className, maxHeight, style, ...props }: DialogBodyProps): react_jsx_runtime.JSX.Element;
+    ({ className, maxHeight, style, htmlContent, allowHtml, strictSanitization, logWarnings, children, ...props }: DialogBodyProps): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
 /**
@@ -738,109 +761,39 @@ declare const DialogFooter: {
 declare const DialogTitle: React.ForwardRefExoticComponent<DialogTitleProps & React.RefAttributes<HTMLHeadingElement>>;
 declare const DialogDescription: React.ForwardRefExoticComponent<DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
 
-declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
-declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
-declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
-declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
-    inset?: boolean;
-} & React.RefAttributes<HTMLDivElement>>;
-/**
- * DropdownMenuSubContent component
- * The content container for dropdown menu sub-items
- *
- * @param props - Content configuration and styling
- * @param ref - Forwarded ref to the content element
- * @returns JSX.Element - The dropdown menu sub-content container
- *
- * @example
- * ```tsx
- * <DropdownMenuSubContent>
- *   <DropdownMenuItem>Option 1</DropdownMenuItem>
- *   <DropdownMenuItem>Option 2</DropdownMenuItem>
- * </DropdownMenuSubContent>
- * ```
- */
-declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-/**
- * DropdownMenuContent component
- * The main content container for dropdown menu items
- *
- * @param props - Content configuration and styling
- * @param ref - Forwarded ref to the content element
- * @returns JSX.Element - The dropdown menu content container
- *
- * @example
- * ```tsx
- * <DropdownMenuContent>
- *   <DropdownMenuItem>Profile</DropdownMenuItem>
- *   <DropdownMenuItem>Settings</DropdownMenuItem>
- * </DropdownMenuContent>
- * ```
- */
-declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-/**
- * DropdownMenuItem component
- * Individual menu item within the dropdown
- *
- * @param props - Item configuration and styling
- * @param ref - Forwarded ref to the item element
- * @returns JSX.Element - The dropdown menu item
- *
- * @example
- * ```tsx
- * <DropdownMenuItem onClick={() => console.log('clicked')}>
- *   Profile
- * </DropdownMenuItem>
- * ```
- */
-declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
-    inset?: boolean;
-} & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
-    inset?: boolean;
-} & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuShortcut: {
-    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
-    displayName: string;
-};
-
 /**
- * @file Custom Select Component System
+ * @file Select Component - Simple HTML Structure
  * @package @jmruthers/pace-core
  * @module Components/Select
- * @since 0.2.0
+ * @since 0.3.0
  *
- * A custom select component system built without Radix UI dependencies.
- * Uses pace-core Button component and eliminates unnecessary wrapper elements.
+ * A simple select component using semantic HTML structure
+ * with proper DOM nesting and accessibility.
  *
  * Features:
- * - Uses pace-core Button component for consistent styling
- * - No wrapper spans with pointer-events: none
- * - Advanced keyboard navigation
- * - Search functionality with fuzzy matching
- * - Accessible design
- * - Simple CSS positioning (no portals)
- * - Custom styling and theming
+ * - Semantic HTML with <form> + <button> + <ul> + <li>
+ * - Proper DOM nesting (no button inside select)
+ * - Built on pace-core Button component for consistency
+ * - Simple positioning and styling
+ * - Better accessibility and SEO
+ * - Backward compatible API
  */
 
-interface SelectProps {
+interface SelectProps extends Omit<React.HTMLAttributes<HTMLFormElement>, 'onChange' | 'onKeyDown' | 'onFocus' | 'onBlur'> {
     value?: string;
     defaultValue?: string;
+    selectedText?: string;
     onValueChange?: (value: string) => void;
     open?: boolean;
     defaultOpen?: boolean;
     onOpenChange?: (open: boolean) => void;
     disabled?: boolean;
     children: React.ReactNode;
+    className?: string;
 }
 interface SelectTriggerProps extends Omit<ButtonProps, 'onClick' | 'onKeyDown'> {
     children: React.ReactNode;
+    asChild?: boolean;
 }
 interface SelectValueProps {
     placeholder?: string;
@@ -851,22 +804,21 @@ interface SelectContentProps {
     className?: string;
     searchable?: boolean;
     searchPlaceholder?: string;
-    position?: 'top' | 'bottom' | 'auto';
-    align?: 'start' | 'center' | 'end';
-    sideOffset?: number;
     maxHeight?: string;
+    style?: React.CSSProperties;
 }
 interface SelectItemProps {
     value: string;
     children: React.ReactNode;
     disabled?: boolean;
     className?: string;
+    onClick?: (e: React.MouseEvent) => void;
 }
-declare const Select: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<HTMLDivElement>>;
+declare const Select: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<HTMLFormElement>>;
 declare const SelectTrigger: React.ForwardRefExoticComponent<SelectTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const SelectValue: React.ForwardRefExoticComponent<SelectValueProps & React.RefAttributes<HTMLDivElement>>;
-declare const SelectContent: React.ForwardRefExoticComponent<SelectContentProps & React.RefAttributes<HTMLDivElement>>;
-declare const SelectItem: React.ForwardRefExoticComponent<SelectItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<SelectContentProps & React.RefAttributes<HTMLUListElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<SelectItemProps & React.RefAttributes<HTMLLIElement>>;
 declare const SelectGroup: React.ForwardRefExoticComponent<{
     children: React.ReactNode;
     className?: string;
@@ -1049,7 +1001,7 @@ declare function Toaster(): react_jsx_runtime.JSX.Element;
  *     <TooltipTrigger asChild>
  *       <Button>Advanced Tooltip</Button>
  *     </TooltipTrigger>
- *     <TooltipContent side="top" className="bg-app-main-500 text-app-main-50">
+ *     <TooltipContent side="top" className="bg-main-500 text-main-50">
  *       <div className="space-y-1">
  *         <p className="font-semibold">Advanced Tooltip</p>
  *         <p className="text-xs">With custom styling</p>
@@ -1098,7 +1050,7 @@ declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.T
  *
  * @example
  * ```tsx
- * <TooltipContent side="top" className="bg-app-main-500">
+ * <TooltipContent side="top" className="bg-main-500">
  *   Custom tooltip content
  * </TooltipContent>
  * ```
@@ -1499,7 +1451,7 @@ interface NavigationMenuProps {
  *           window.location.href = item.href;
  *         }
  *       }}
- *       className="w-64 bg-gray-50 p-4"
+ *       className="w-64 bg-sec-50 p-4"
  *     />
  *   );
  * }
@@ -1597,7 +1549,6 @@ interface NavigationMenuProps {
  * - Uses Tailwind CSS for consistent styling
  * - Supports custom className for additional styling
  * - Responsive design considerations
- * - Dark mode compatible color schemes
  *
  * @dependencies
  * - React 18+ - Component framework and hooks
@@ -1692,7 +1643,7 @@ interface NavigationMenuProps {
  *           window.location.href = item.href;
  *         }
  *       }}
- *       className="w-64 bg-gray-50 p-4"
+ *       className="w-64 bg-sec-50 p-4"
  *     />
  *   );
  * }
@@ -1710,16 +1661,35 @@ interface NavigationMenuProps {
  *   const location = useLocation();
  *   const { hasRole, hasPermission } = useUnifiedAuth();
  *
- *   // Build navigation items based on user permissions
+ *   // Build navigation items with permission requirements
  *   const navItems = [
- *     { id: 'dashboard', label: 'Dashboard', href: '/dashboard', icon: 'LayoutDashboard' },
- *     ...(hasPermission('meals:read') ? [
- *       { id: 'meals', label: 'Meals', href: '/meals', icon: 'UtensilsCrossed' }
- *     ] : []),
- *     ...(hasRole('admin') ? [
- *       { id: 'admin', label: 'Admin Panel', href: '/admin', icon: 'Shield' }
- *     ] : []),
- *     { id: 'profile', label: 'Profile', href: '/profile', icon: 'User' }
+ *     {
+ *       id: 'dashboard',
+ *       label: 'Dashboard',
+ *       href: '/dashboard',
+ *       icon: 'LayoutDashboard',
+ *       permissions: ['dashboard:read']
+ *     },
+ *     {
+ *       id: 'meals',
+ *       label: 'Meals',
+ *       href: '/meals',
+ *       icon: 'UtensilsCrossed',
+ *       permissions: ['meals:read']
+ *     },
+ *     {
+ *       id: 'admin',
+ *       label: 'Admin Panel',
+ *       href: '/admin',
+ *       icon: 'Shield',
+ *       roles: ['admin', 'super_admin']
+ *     },
+ *     {
+ *       id: 'profile',
+ *       label: 'Profile',
+ *       href: '/profile',
+ *       icon: 'User'
+ *     }
  *   ];
  *
  *   return (
@@ -1730,6 +1700,8 @@ interface NavigationMenuProps {
  *       onNavigate={(item) => navigate(item.href)}
  *       buttonText="Navigation"
  *       navigationLabel="Main application navigation"
+ *       filterByPermissions={true}
+ *       auditLog={true}
  *     />
  *   );
  * }
@@ -2238,7 +2210,7 @@ interface PaceAppLayoutProps {
  * - Automatic page permission validation
  *
  * @example
- * Basic React Router setup with permission enforcement:
+ * Basic React Router setup with permission enforcement (RECOMMENDED):
  * ```tsx
  * import { BrowserRouter as Router, Routes, Route } from 'react-router-dom';
  * import { UnifiedAuthProvider } from '@jmruthers/pace-core/providers';
@@ -2268,6 +2240,7 @@ interface PaceAppLayoutProps {
  * }
  * ```
  *
+ *
  * @example
  * Custom navigation items with permission filtering:
  * ```tsx
@@ -2595,7 +2568,7 @@ declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryS
  * // With custom styling
  * <LoadingSpinner
  *   size="lg"
- *   className="text-app-main-500"
+ *   className="text-main-500"
  * />
  *
  * // In a button
@@ -2641,7 +2614,7 @@ interface LoadingSpinnerProps {
  *
  * @example
  * ```tsx
- * <LoadingSpinner size="lg" className="text-app-main-500" />
+ * <LoadingSpinner size="lg" className="text-main-500" />
  * ```
  */
 declare const LoadingSpinner: React__default.FC<LoadingSpinnerProps>;
@@ -2747,7 +2720,7 @@ declare function OrganisationSelector({ placeholder, className, onOrganisationCh
  *
  * // Password reset form with custom styling
  * <PasswordResetForm
- *   className="max-w-md mx-auto p-6 bg-app-main-50 rounded-lg shadow-md"
+ *   className="max-w-md mx-auto p-6 bg-main-50 rounded-lg shadow-md"
  *   onSuccess={() => {
  *     console.log('Reset email sent successfully');
  *     navigate('/check-email');
@@ -2798,6 +2771,153 @@ interface PasswordResetFormProps {
 }
 declare function PasswordResetForm({ onSuccess, onError, className }: PasswordResetFormProps): react_jsx_runtime.JSX.Element;
 
+interface FileUploadProps {
+    supabase: SupabaseClient;
+    appName: string;
+    orgId: string;
+    onUploadComplete?: (result: {
+        success: boolean;
+        path?: string;
+        error?: string;
+    }) => void;
+    onUploadStart?: () => void;
+    accept?: string;
+    maxSize?: number;
+    multiple?: boolean;
+    disabled?: boolean;
+    className?: string;
+    children?: React__default.ReactNode;
+}
+declare function FileUpload({ supabase, appName, orgId, onUploadComplete, onUploadStart, accept, maxSize, multiple, disabled, className, children }: FileUploadProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Storage utility types for pace-core
+ */
+interface StorageUploadOptions {
+    /** The app name from rbac_apps */
+    appName: string;
+    /** Organisation ID for scoping */
+    orgId: string;
+    /** Whether the file should be publicly accessible */
+    isPublic?: boolean;
+    /** Optional tags for categorisation */
+    tags?: string[];
+    /** Optional custom path within the app/org structure */
+    customPath?: string;
+    /** Optional metadata to store with the file */
+    metadata?: Record<string, any>;
+}
+interface StorageFileMetadata {
+    mimeType: string;
+    size: number;
+    width?: number;
+    height?: number;
+    hash?: string;
+    orgId: string;
+    appName: string;
+    uploadedBy: string;
+    uploadedAt: string;
+    tags?: string[];
+    isPublic: boolean;
+    customMetadata?: Record<string, any>;
+}
+interface StorageUploadResult {
+    success: boolean;
+    path?: string;
+    publicUrl?: string;
+    metadata?: StorageFileMetadata;
+    error?: string;
+}
+interface StorageUrlOptions {
+    /** The app name from rbac_apps */
+    appName: string;
+    /** Organisation ID for scoping */
+    orgId: string;
+    /** Expiry time in seconds for signed URLs (default: 3600) */
+    expiresIn?: number;
+}
+interface StorageListOptions {
+    /** The app name from rbac_apps */
+    appName: string;
+    /** Organisation ID for scoping */
+    orgId: string;
+    /** Optional path prefix to filter by */
+    pathPrefix?: string;
+    /** Optional tags to filter by */
+    tags?: string[];
+    /** Maximum number of files to return */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+}
+interface StorageFileInfo {
+    name: string;
+    path: string;
+    size: number;
+    mimeType: string;
+    lastModified: string;
+    metadata: StorageFileMetadata;
+}
+interface StorageListResult {
+    files: StorageFileInfo[];
+    totalCount: number;
+    hasMore: boolean;
+}
+interface FileSizeLimits {
+    [mimeType: string]: number;
+}
+interface StorageConfig {
+    bucketName: string;
+    fileSizeLimits: FileSizeLimits;
+    defaultFileSizeLimit: number;
+}
+
+/**
+ * React hook for storage operations
+ */
+
+interface UseStorageOptions {
+    supabase: SupabaseClient;
+    appName: string;
+    orgId: string;
+}
+interface UseStorageReturn {
+    uploadFile: (file: File, options?: Partial<StorageUploadOptions>) => Promise<StorageUploadResult>;
+    isUploading: boolean;
+    uploadError: string | null;
+    getPublicUrl: (path: string) => string;
+    getSignedUrl: (path: string, expiresIn?: number) => Promise<string | null>;
+    getFileUrl: (path: string) => string;
+    deleteFile: (path: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    archiveFile: (path: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    listFiles: (options?: Partial<StorageListOptions>) => Promise<StorageListResult>;
+    isListing: boolean;
+    listError: string | null;
+    isLoading: boolean;
+    error: string | null;
+    files: StorageFileInfo[];
+    refreshFiles: () => Promise<void>;
+}
+/**
+ * Hook for storage operations with app and organisation context
+ */
+declare function useStorage({ supabase, appName, orgId }: UseStorageOptions): UseStorageReturn;
+/**
+ * Hook for file upload with progress tracking
+ */
+declare function useFileUpload({ supabase, appName, orgId }: UseStorageOptions): {
+    uploadWithProgress: (file: File, options?: Partial<StorageUploadOptions>) => Promise<StorageUploadResult>;
+    uploadProgress: number;
+    isUploading: boolean;
+    uploadError: string | null;
+};
+
 /**
  * @file Table Component System
  * @package @jmruthers/pace-core
@@ -2914,4 +3034,397 @@ declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<
 declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
 declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
 
-export { SelectLabel as $, Alert as A, Button as B, Card as C, Dialog as D, DropdownMenu as E, DropdownMenuTrigger as F, DropdownMenuContent as G, DropdownMenuItem as H, Input as I, DropdownMenuCheckboxItem as J, DropdownMenuRadioItem as K, Label as L, DropdownMenuLabel as M, DropdownMenuSeparator as N, DropdownMenuShortcut as O, Progress as P, DropdownMenuGroup as Q, DropdownMenuPortal as R, DropdownMenuSub as S, DropdownMenuSubContent as T, DropdownMenuSubTrigger as U, DropdownMenuRadioGroup as V, Select as W, SelectGroup as X, SelectValue as Y, SelectTrigger as Z, SelectContent as _, type ButtonProps as a, SelectItem as a0, SelectSeparator as a1, Toast as a2, Toaster as a3, ToastAction as a4, ToastProvider as a5, ToastViewport as a6, ToastTitle as a7, ToastDescription as a8, ToastClose as a9, OrganisationSelector as aA, PasswordResetForm as aB, Table as aC, TableHeader as aD, TableBody as aE, TableCaption as aF, TableCell as aG, TableFooter as aH, TableHead as aI, TableRow as aJ, type CardActionsProps as aK, type DialogProps as aL, type DialogTriggerProps as aM, type DialogContentProps as aN, type DialogOverlayProps as aO, type DialogHeaderProps as aP, type DialogFooterProps as aQ, type DialogTitleProps as aR, type DialogDescriptionProps as aS, type DialogSize as aT, type FormProps as aU, type OrganisationSelectorProps as aV, type ErrorBoundaryProps as aW, type ErrorBoundaryState as aX, useToast as aa, type ToastActionElement as ab, type ToastProps as ac, Tooltip as ad, TooltipTrigger as ae, TooltipContent as af, TooltipProvider as ag, TooltipRoot as ah, Form as ai, LoginForm as aj, type LoginFormProps as ak, Header as al, Footer as am, type FooterProps as an, NavigationMenu as ao, type NavigationMenuProps as ap, type NavigationItem as aq, UserMenu as ar, type UserMenuProps as as, PaceAppLayout as at, type PaceAppLayoutProps as au, PaceLoginPage as av, type PaceLoginPageProps as aw, ErrorBoundary as ax, LoadingSpinner as ay, EventSelector as az, CardHeader as b, CardFooter as c, CardTitle as d, CardDescription as e, CardContent as f, CardActions as g, type CardProps as h, type InputProps as i, type LabelProps as j, AlertTitle as k, AlertDescription as l, Avatar as m, AvatarImage as n, AvatarFallback as o, Checkbox as p, DialogPortal as q, DialogOverlay as r, DialogTrigger as s, DialogClose as t, DialogContent as u, DialogHeader as v, DialogBody as w, DialogFooter as x, DialogTitle as y, DialogDescription as z };
+interface PublicPageLayoutProps {
+    /** The event code for this public page */
+    eventCode: string;
+    /** Child components to render */
+    children: ReactNode;
+    /** Optional event data - if not provided, will be fetched by parent component */
+    event?: Event | null;
+    /** Whether to show the footer (default: true) */
+    showFooter?: boolean;
+    /** Custom CSS classes for the layout */
+    className?: string;
+    /** Custom error fallback component */
+    errorFallback?: React__default.ComponentType<{
+        error: Error;
+        retry: () => void;
+    }>;
+    /** Custom loading fallback component */
+    loadingFallback?: React__default.ComponentType;
+    /** Custom header component */
+    customHeader?: ReactNode;
+    /** Custom footer component */
+    customFooter?: ReactNode;
+    /** Whether to show event validation errors (default: true) */
+    showValidationErrors?: boolean;
+}
+/**
+ * Layout component for public pages that don't require authentication
+ *
+ * This component provides a consistent structure for public event pages
+ * with event-specific branding, error handling, and loading states.
+ *
+ * @param props - Layout configuration and content
+ * @returns React element with complete public page layout
+ */
+declare function PublicPageLayout({ eventCode, children, event, showFooter, className, errorFallback: ErrorFallback, loadingFallback: LoadingFallback, customHeader, customFooter, showValidationErrors }: PublicPageLayoutProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook for accessing public page context
+ * Provides access to event data and layout state within public pages
+ *
+ * @deprecated This hook is no longer needed as PublicPageLayout no longer
+ * automatically fetches event data. Use usePublicRouteParams and usePublicEvent
+ * directly in your components instead.
+ */
+declare function usePublicPageContext$1(): {
+    eventCode: null;
+    eventId: null;
+    event: null;
+    isLoading: boolean;
+    error: null;
+    refetch: () => Promise<void>;
+    isPublicPage: boolean;
+};
+
+interface PublicPageHeaderProps {
+    /** The event data for this public page */
+    event: Event;
+    /** The event code for this public page */
+    eventCode: string;
+    /** Optional page title */
+    title?: string;
+    /** Optional page description */
+    description?: string;
+    /** Whether to show the event logo (default: true) */
+    showEventLogo?: boolean;
+    /** Whether to show the app logo (default: true) */
+    showAppLogo?: boolean;
+    /** Custom CSS classes for the header */
+    className?: string;
+    /** Custom content to display in the header */
+    children?: ReactNode;
+    /** Custom app logo component */
+    customAppLogo?: ReactNode;
+    /** Custom event logo component */
+    customEventLogo?: ReactNode;
+}
+/**
+ * Header component for public pages with event-specific branding
+ *
+ * This component displays the app logo, event logo, and event information
+ * in a clean, accessible layout suitable for public pages.
+ *
+ * @param props - Header configuration and content
+ * @returns React element with public page header
+ */
+declare function PublicPageHeader({ event, eventCode, title, description, showEventLogo, showAppLogo, className, children, customAppLogo, customEventLogo }: PublicPageHeaderProps): react_jsx_runtime.JSX.Element;
+
+interface PublicPageContextType {
+    isPublicPage: true;
+    supabase: ReturnType<typeof createClient<Database>> | null;
+    environment: {
+        supabaseUrl: string | null;
+        supabaseKey: string | null;
+    };
+}
+interface PublicPageProviderProps {
+    children: ReactNode;
+}
+/**
+ * Provider for public pages that completely isolates them from authentication context
+ *
+ * This provider:
+ * - Does not initialize any authentication providers
+ * - Provides environment variables for public data access
+ * - Includes error boundary for graceful error handling
+ * - Is completely separate from the main app context
+ */
+declare function PublicPageProvider({ children }: PublicPageProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access public page context
+ *
+ * @returns Public page context with environment variables
+ */
+declare function usePublicPageContext(): PublicPageContextType;
+/**
+ * Hook to check if we're in a public page context
+ *
+ * @returns True if we're in a public page context
+ */
+declare function useIsPublicPage(): boolean;
+
+interface PublicPageFooterProps {
+    /** The event data for this public page */
+    event: Event;
+    /** Company or organization name */
+    companyName?: string;
+    /** Current year or custom year for copyright */
+    year?: number;
+    /** Optional array of navigation links to display */
+    links?: Array<{
+        label: string;
+        href: string;
+    }>;
+    /** Optional CSS class name */
+    className?: string;
+    /** Logo image URL */
+    logo?: string;
+    /** Copyright text */
+    copyright?: string;
+    /** Footer content - children to render inside footer */
+    children?: React__default.ReactNode;
+}
+/**
+ * Footer component for public pages that matches the normal Footer exactly
+ *
+ * This component uses the same styling and structure as the main Footer component
+ * to ensure consistency across the application.
+ *
+ * @param props - Footer configuration and content
+ * @returns React element with public page footer
+ */
+declare function PublicPageFooter({ event, companyName, year, links, className, logo, copyright, children }: PublicPageFooterProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * @file Public Page Debugger
+ * @package @jmruthers/pace-core
+ * @module Components/PublicLayout
+ * @since 1.0.0
+ *
+ * A debugging component that helps identify why authentication context
+ * is being triggered in public pages.
+ */
+interface PublicPageDebuggerProps {
+    /** Whether to enable debugging */
+    enabled?: boolean;
+    /** Custom label for this debugger instance */
+    label?: string;
+}
+/**
+ * Debugger component that logs context information
+ *
+ * This component helps identify why authentication context
+ * is being triggered in public pages.
+ */
+declare function PublicPageDebugger({ enabled, label }: PublicPageDebuggerProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * @file Public Page Diagnostic Component
+ * @package @jmruthers/pace-core
+ * @module Components/PublicLayout
+ * @since 1.0.0
+ *
+ * A diagnostic component that helps identify exactly where authentication
+ * context is being triggered in public pages.
+ */
+interface PublicPageDiagnosticProps {
+    /** Whether to enable diagnostics */
+    enabled?: boolean;
+    /** Custom label for this diagnostic instance */
+    label?: string;
+}
+/**
+ * Diagnostic component that identifies authentication context issues
+ *
+ * This component will help you identify exactly where the problem is
+ * in your public page implementation.
+ */
+declare function PublicPageDiagnostic({ enabled, label }: PublicPageDiagnosticProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * @file Public Page Context Checker
+ * @package @jmruthers/pace-core
+ * @module Components/PublicLayout
+ * @since 1.0.0
+ *
+ * A simple component that immediately identifies if a public page
+ * is being rendered inside authentication context.
+ */
+interface PublicPageContextCheckerProps {
+    /** Whether to enable checking */
+    enabled?: boolean;
+    /** Custom label for this checker instance */
+    label?: string;
+}
+/**
+ * Context checker component that immediately identifies authentication context issues
+ *
+ * This component will immediately log to console if authentication context
+ * is being triggered in a public page.
+ */
+declare function PublicPageContextChecker({ enabled, label }: PublicPageContextCheckerProps): react_jsx_runtime.JSX.Element | null;
+
+interface EventLogoProps {
+    /** The event ID to fetch logo for */
+    eventId: string;
+    /** The event name for fallback text generation */
+    eventName: string;
+    /** The organisation ID for storage path */
+    organisationId: string;
+    /** Logo size variant */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    /** Custom CSS classes */
+    className?: string;
+    /** Whether to show fallback text when no logo is available */
+    showFallback?: boolean;
+    /** Custom fallback text generator */
+    generateFallbackText?: (eventName: string) => string;
+    /** Whether to validate image existence */
+    validateImage?: boolean;
+    /** Custom loading component */
+    loadingComponent?: React__default.ComponentType;
+    /** Custom error component */
+    errorComponent?: React__default.ComponentType<{
+        error: Error;
+    }>;
+}
+/**
+ * Component for displaying event logos with fallback to initials
+ *
+ * This component is context-aware and automatically detects whether it's being used
+ * in a public or authenticated context. It fetches and displays event logos from storage,
+ * with automatic fallback to event initials if no logo is available.
+ *
+ * @param props - Logo configuration and styling
+ * @returns React element with event logo or fallback
+ */
+declare function EventLogo({ eventId, eventName, organisationId, size, className, showFallback, generateFallbackText, validateImage, loadingComponent: LoadingComponent, errorComponent: ErrorComponent }: EventLogoProps): react_jsx_runtime.JSX.Element | null;
+/**
+ * Compact event logo for small spaces
+ */
+declare function EventLogoCompact(props: EventLogoProps): react_jsx_runtime.JSX.Element;
+/**
+ * Large event logo for prominent display
+ */
+declare function EventLogoLarge(props: EventLogoProps): react_jsx_runtime.JSX.Element;
+
+interface PublicErrorBoundaryProps {
+    /** Child components to wrap */
+    children: ReactNode;
+    /** Custom error fallback component */
+    fallback?: React__default.ComponentType<PublicErrorBoundaryState>;
+    /** Custom CSS classes for error display */
+    className?: string;
+    /** Whether to show error details in development */
+    showErrorDetails?: boolean;
+    /** Custom error message */
+    customErrorMessage?: string;
+    /** Custom recovery action */
+    onRecover?: () => void;
+}
+interface PublicErrorBoundaryState {
+    /** Whether an error has occurred */
+    hasError: boolean;
+    /** The error that occurred */
+    error: Error | null;
+    /** Error information */
+    errorInfo: ErrorInfo | null;
+    /** Function to reset the error state */
+    resetError: () => void;
+}
+/**
+ * Error boundary component for public pages
+ *
+ * This component catches JavaScript errors anywhere in the child component tree,
+ * logs those errors, and displays a fallback UI instead of the component tree that crashed.
+ *
+ * @param props - Error boundary configuration
+ * @returns React element with error boundary wrapper
+ */
+declare class PublicErrorBoundary extends Component<PublicErrorBoundaryProps, PublicErrorBoundaryState> {
+    constructor(props: PublicErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): Partial<PublicErrorBoundaryState>;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    resetError: () => void;
+    render(): string | number | boolean | Iterable<React__default.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;
+}
+/**
+ * Hook for accessing error boundary state
+ * Useful for components that need to know if they're inside an error boundary
+ */
+declare function useErrorBoundary(): {
+    captureError: (error: Error) => void;
+    resetError: () => void;
+};
+/**
+ * Default error fallback component
+ */
+declare function DefaultPublicErrorFallback({ error, resetError }: PublicErrorBoundaryState): react_jsx_runtime.JSX.Element;
+
+/**
+ * @file Public Loading Spinner Component
+ * @package @jmruthers/pace-core
+ * @module Components/PublicLayout
+ * @since 1.0.0
+ *
+ * A loading spinner component specifically designed for public pages.
+ * Provides consistent loading states with event-specific branding.
+ *
+ * Features:
+ * - Consistent loading design
+ * - Event-specific branding
+ * - Multiple size options
+ * - Accessibility compliant
+ * - TypeScript support
+ *
+ * @example
+ * ```tsx
+ * import { PublicLoadingSpinner } from '@jmruthers/pace-core';
+ *
+ * function PublicEventPage() {
+ *   if (isLoading) {
+ *     return <PublicLoadingSpinner message="Loading event details..." />;
+ *   }
+ * }
+ * ```
+ *
+ * @accessibility
+ * - WCAG 2.1 AA compliant
+ * - Screen reader friendly
+ * - Proper ARIA labels
+ * - High contrast support
+ *
+ * @dependencies
+ * - React 18+ - Component framework
+ * - Tailwind CSS - Styling
+ */
+interface PublicLoadingSpinnerProps {
+    /** Loading message to display */
+    message?: string;
+    /** Size variant */
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    /** Custom CSS classes */
+    className?: string;
+    /** Whether to show the app logo */
+    showLogo?: boolean;
+    /** Custom loading message */
+    customMessage?: string;
+    /** Whether to center the spinner */
+    centered?: boolean;
+}
+/**
+ * Loading spinner component for public pages
+ *
+ * This component displays a consistent loading state with optional
+ * branding and messaging for public pages.
+ *
+ * @param props - Spinner configuration and styling
+ * @returns React element with loading spinner
+ */
+declare function PublicLoadingSpinner({ message, size, className, showLogo, customMessage, centered }: PublicLoadingSpinnerProps): react_jsx_runtime.JSX.Element;
+/**
+ * Full page loading spinner with event branding
+ */
+declare function PublicLoadingSpinnerFullPage({ message, eventName, className }: Pick<PublicLoadingSpinnerProps, 'message' | 'className'> & {
+    eventName?: string;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Skeleton loading component for content placeholders
+ */
+declare function PublicLoadingSkeleton({ lines, className }: {
+    lines?: number;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+export { ToastViewport as $, Alert as A, Button as B, Card as C, Dialog as D, DialogContent as E, type FileSizeLimits as F, DialogHeader as G, DialogBody as H, Input as I, DialogFooter as J, DialogTitle as K, Label as L, DialogDescription as M, Select as N, SelectGroup as O, Progress as P, SelectValue as Q, SelectTrigger as R, type StorageConfig as S, SelectContent as T, SelectLabel as U, SelectItem as V, SelectSeparator as W, Toast as X, Toaster as Y, ToastAction as Z, ToastProvider as _, type StorageUploadOptions as a, type PublicPageLayoutProps as a$, ToastTitle as a0, ToastDescription as a1, ToastClose as a2, useToast as a3, type ToastActionElement as a4, type ToastProps as a5, Tooltip as a6, TooltipTrigger as a7, TooltipContent as a8, TooltipProvider as a9, TableHeader as aA, TableBody as aB, TableCaption as aC, TableCell as aD, TableFooter as aE, TableHead as aF, TableRow as aG, type StorageFileInfo as aH, PublicPageLayout as aI, usePublicPageContext$1 as aJ, PublicPageHeader as aK, PublicPageProvider as aL, usePublicPageContext as aM, useIsPublicPage as aN, PublicPageFooter as aO, PublicPageDebugger as aP, PublicPageDiagnostic as aQ, PublicPageContextChecker as aR, EventLogo as aS, EventLogoCompact as aT, EventLogoLarge as aU, PublicErrorBoundary as aV, useErrorBoundary as aW, DefaultPublicErrorFallback as aX, PublicLoadingSpinner as aY, PublicLoadingSpinnerFullPage as aZ, PublicLoadingSkeleton as a_, TooltipRoot as aa, Form as ab, LoginForm as ac, type LoginFormProps as ad, Header as ae, Footer as af, type FooterProps as ag, NavigationMenu as ah, type NavigationMenuProps as ai, type NavigationItem as aj, UserMenu as ak, type UserMenuProps as al, PaceAppLayout as am, type PaceAppLayoutProps as an, PaceLoginPage as ao, type PaceLoginPageProps as ap, ErrorBoundary as aq, LoadingSpinner as ar, EventSelector as as, OrganisationSelector as at, PasswordResetForm as au, FileUpload as av, type FileUploadProps as aw, useStorage as ax, useFileUpload as ay, Table as az, type StorageUploadResult as b, type PublicPageHeaderProps as b0, type PublicPageFooterProps as b1, type EventLogoProps as b2, type PublicErrorBoundaryProps as b3, type PublicErrorBoundaryState as b4, type PublicLoadingSpinnerProps as b5, type CardActionsProps as b6, type DialogProps as b7, type DialogTriggerProps as b8, type DialogContentProps as b9, type DialogOverlayProps as ba, type DialogHeaderProps as bb, type DialogFooterProps as bc, type DialogTitleProps as bd, type DialogDescriptionProps as be, type DialogSize as bf, type FormProps as bg, type OrganisationSelectorProps as bh, type ErrorBoundaryProps as bi, type ErrorBoundaryState as bj, type UseStorageOptions as bk, type UseStorageReturn as bl, type StorageUrlOptions as c, type StorageListOptions as d, type StorageListResult as e, type StorageFileMetadata as f, type ButtonProps as g, CardHeader as h, CardFooter as i, CardTitle as j, CardDescription as k, CardContent as l, CardActions as m, type CardProps as n, type InputProps as o, type LabelProps as p, AlertTitle as q, AlertDescription as r, Avatar as s, AvatarImage as t, AvatarFallback as u, Checkbox as v, DialogPortal as w, DialogOverlay as x, DialogTrigger as y, DialogClose as z };