@djangocfg/layouts 2.1.101 → 2.1.102

package/dist/index.d.mts

@@ -0,0 +1,2376 @@
+import React$1, { ErrorInfo, ReactNode, Component } from 'react';
+import { LucideIcon as LucideIcon$1 } from 'lucide-react';
+import { AuthConfig, AuthLayoutProps, AuthFormContextType, AuthHelpProps } from '@djangocfg/api/auth';
+export { AuthChannel, AuthFormContextType, AuthFormState, AuthHelpProps, AuthLayoutConfig, AuthLayoutProps, AuthStep } from '@djangocfg/api/auth';
+import { ZodError } from 'zod';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+export { useRouter } from 'nextjs-toploader/app';
+import { ButtonProps } from '@djangocfg/ui-nextjs';
+import * as consola from 'consola';
+
+/**
+ * Provider Configuration Types
+ *
+ * Configuration types for layout providers (theme, SWR, MCP chat, Centrifugo)
+ * Note: Analytics, PWA, Push, and Error types are defined in their respective modules
+ */
+interface ThemeConfig {
+    defaultTheme?: 'light' | 'dark' | 'system';
+    storageKey?: string;
+}
+interface SWRConfigOptions {
+    revalidateOnFocus?: boolean;
+    revalidateOnReconnect?: boolean;
+    dedupingInterval?: number;
+}
+interface McpChatConfig {
+    /** Enable MCP chat widget */
+    enabled?: boolean;
+    /** API endpoint for chat */
+    apiEndpoint?: string;
+    /** Chat widget title */
+    title?: string;
+    /** Input placeholder */
+    placeholder?: string;
+    /** Greeting message */
+    greeting?: string;
+    /** Widget position */
+    position?: 'bottom-right' | 'bottom-left';
+    /** Widget variant */
+    variant?: 'default' | 'minimal';
+    /** Enable streaming responses */
+    enableStreaming?: boolean;
+    /** Auto-detect environment (dev/prod) */
+    autoDetectEnvironment?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+interface CentrifugoConfig {
+    /** Enable Centrifugo (default: true) */
+    enabled?: boolean;
+    /** Auto-connect on mount (default: false) */
+    autoConnect?: boolean;
+    /** Centrifugo server URL */
+    url?: string;
+}
+
+/**
+ * Analytics Configuration Types
+ *
+ * Configuration for Google Analytics integration
+ */
+interface AnalyticsConfig {
+    /** Google Analytics tracking ID (e.g., 'G-XXXXXXXXXX') */
+    googleTrackingId?: string;
+}
+
+/**
+ * PWA Install Configuration Types
+ *
+ * Configuration for Progressive Web App installation features
+ */
+interface PwaInstallConfig {
+    /** Enable PWA installation features */
+    enabled?: boolean;
+    /** Show A2HS (Add to Home Screen) hint (enabled by default when enabled is true) */
+    showInstallHint?: boolean;
+    /** Number of days before re-showing dismissed hint (null = never show again) */
+    resetAfterDays?: number | null;
+    /** Delay before showing hint (ms) */
+    delayMs?: number;
+    /** App logo URL to display in hint */
+    logo?: string;
+    /**
+     * Resume last page when opening PWA
+     * When enabled, saves current pathname on navigation and restores it on PWA launch
+     * @default false
+     */
+    resumeLastPage?: boolean;
+}
+
+/**
+ * Platform Detection Types
+ */
+/**
+ * Platform detection result
+ */
+interface PlatformInfo {
+    isIOS: boolean;
+    isAndroid: boolean;
+    isDesktop: boolean;
+    isSafari: boolean;
+    isChrome: boolean;
+    isEdge: boolean;
+    isFirefox: boolean;
+    isStandalone: boolean;
+    canPrompt: boolean;
+    shouldShowAndroidPrompt: boolean;
+    shouldShowIOSGuide: boolean;
+}
+
+/**
+ * PWA Installation Types
+ */
+/**
+ * Install prompt state
+ */
+interface InstallPromptState {
+    isIOS: boolean;
+    isAndroid: boolean;
+    isSafari: boolean;
+    isChrome: boolean;
+    isInstalled: boolean;
+    canPrompt: boolean;
+    deferredPrompt: BeforeInstallPromptEvent | null;
+}
+/**
+ * BeforeInstallPrompt event (Android Chrome)
+ */
+interface BeforeInstallPromptEvent extends Event {
+    prompt: () => Promise<void>;
+    userChoice: Promise<{
+        outcome: 'accepted' | 'dismissed';
+        platform: string;
+    }>;
+}
+/**
+ * Install outcome
+ */
+type InstallOutcome = 'accepted' | 'dismissed' | null;
+/**
+ * iOS guide dismissal state
+ */
+interface IOSGuideState {
+    dismissed: boolean;
+    dismissedAt: number | null;
+    shouldShow: boolean;
+}
+
+/**
+ * Component Props Types
+ */
+
+/**
+ * Install context type
+ */
+interface InstallContextType {
+    platform: PlatformInfo;
+    isInstalled: boolean;
+    canPrompt: boolean;
+    showIOSGuide: boolean;
+    setShowIOSGuide: (show: boolean) => void;
+    promptInstall: () => Promise<InstallOutcome>;
+    dismissIOSGuide: () => void;
+}
+/**
+ * Install manager props
+ */
+interface InstallManagerProps {
+    /**
+     * Delay before showing iOS guide (ms)
+     * @default 2000
+     */
+    delayMs?: number;
+    /**
+     * Number of days before re-showing dismissed guide
+     * @default 7
+     */
+    resetDays?: number;
+    /**
+     * Custom class name for install button
+     */
+    buttonClassName?: string;
+    /**
+     * Custom button text
+     */
+    buttonText?: string;
+    /**
+     * Force show install UI (ignores platform detection)
+     * Useful for testing on desktop in development
+     * @default false
+     */
+    forceShow?: boolean;
+    /**
+     * Callback when install is successful
+     */
+    onInstallSuccess?: () => void;
+    /**
+     * Callback when install is dismissed
+     */
+    onInstallDismiss?: () => void;
+}
+/**
+ * Android install button props
+ */
+interface AndroidInstallButtonProps {
+    onInstall: () => Promise<InstallOutcome>;
+    className?: string;
+    text?: string;
+}
+/**
+ * iOS guide modal props
+ */
+interface IOSGuideModalProps {
+    onDismiss: () => void;
+    open?: boolean;
+}
+/**
+ * Install step for iOS guide
+ */
+interface InstallStep {
+    number: number;
+    title: string;
+    icon: React.ComponentType<{
+        className?: string;
+    }>;
+    description: string;
+}
+
+/**
+ * Push Notifications Configuration Types
+ *
+ * Configuration for Web Push Notifications with VAPID authentication
+ */
+interface PushNotificationsConfig {
+    /** Enable push notifications */
+    enabled?: boolean;
+    /** VAPID public key for push notifications (required when enabled) */
+    vapidPublicKey: string;
+    /** API endpoint for subscription (default: '/api/push/subscribe') */
+    subscribeEndpoint?: string;
+    /** Only show push prompt if PWA is installed (default: true) */
+    requirePWA?: boolean;
+    /** Delay before showing push prompt after PWA install (ms) */
+    delayMs?: number;
+    /** Number of days before re-showing dismissed push prompt */
+    resetAfterDays?: number;
+    /** Auto-subscribe on mount if permission already granted */
+    autoSubscribe?: boolean;
+}
+
+/**
+ * Push Notification Types
+ */
+/**
+ * Push notification state
+ */
+interface PushNotificationState {
+    isSupported: boolean;
+    permission: NotificationPermission;
+    isSubscribed: boolean;
+    subscription: PushSubscription | null;
+}
+/**
+ * Push notification options
+ */
+interface PushNotificationOptions {
+    vapidPublicKey: string;
+    subscribeEndpoint?: string;
+}
+
+/**
+ * Error Tracking Types
+ *
+ * Common types for all error tracking functionality
+ */
+
+/**
+ * Base error detail from CustomEvent
+ */
+interface BaseErrorDetail {
+    /** Timestamp of the error */
+    timestamp: Date;
+}
+/**
+ * Validation error detail (from zod-validation-error event)
+ */
+interface ValidationErrorDetail extends BaseErrorDetail {
+    type: 'validation';
+    /** Operation/function name that failed validation */
+    operation: string;
+    /** API endpoint path */
+    path: string;
+    /** HTTP method */
+    method: string;
+    /** Zod validation error */
+    error: ZodError;
+    /** Raw response data that failed validation */
+    response: any;
+}
+/**
+ * CORS error detail (from cors-error event)
+ */
+interface CORSErrorDetail extends BaseErrorDetail {
+    type: 'cors';
+    /** API endpoint that was blocked */
+    url: string;
+    /** HTTP method */
+    method: string;
+    /** Error message */
+    error: string;
+}
+/**
+ * Network error detail (from network-error event)
+ */
+interface NetworkErrorDetail extends BaseErrorDetail {
+    type: 'network';
+    /** API endpoint that failed */
+    url: string;
+    /** HTTP method */
+    method: string;
+    /** Error message */
+    error: string;
+    /** Status code if available */
+    statusCode?: number;
+}
+/**
+ * Centrifugo error detail (from centrifugo-error event)
+ */
+interface CentrifugoErrorDetail extends BaseErrorDetail {
+    type: 'centrifugo';
+    /** RPC method that failed */
+    method: string;
+    /** Error message */
+    error: string;
+    /** Error code from Centrifugo */
+    code?: number;
+    /** Additional data sent with the request */
+    data?: any;
+}
+/**
+ * Union type of all error details
+ */
+type ErrorDetail = ValidationErrorDetail | CORSErrorDetail | NetworkErrorDetail | CentrifugoErrorDetail;
+/**
+ * Stored error with unique ID
+ */
+type StoredError<T extends ErrorDetail = ErrorDetail> = T & {
+    /** Unique identifier for this error instance */
+    id: string;
+};
+/**
+ * Configuration for specific error type
+ */
+interface ErrorTypeConfig {
+    /**
+     * Enable tracking for this error type
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Show toast notifications
+     * @default true
+     */
+    showToast?: boolean;
+    /**
+     * Maximum number of errors to keep in history
+     * @default 50
+     */
+    maxErrors?: number;
+    /**
+     * Toast duration in milliseconds (0 = no auto-dismiss)
+     * @default 8000 for validation, 0 for cors/network
+     */
+    duration?: number;
+}
+/**
+ * Validation error specific config
+ */
+interface ValidationErrorConfig extends ErrorTypeConfig {
+    /**
+     * Show operation name in toast
+     * @default true
+     */
+    showOperation?: boolean;
+    /**
+     * Show endpoint path in toast
+     * @default true
+     */
+    showPath?: boolean;
+    /**
+     * Show error count in toast
+     * @default true
+     */
+    showErrorCount?: boolean;
+    /**
+     * Maximum number of issues to show in toast
+     * @default 3
+     */
+    maxIssuesInToast?: number;
+}
+/**
+ * CORS error specific config
+ */
+interface CORSErrorConfig extends ErrorTypeConfig {
+    /**
+     * Show full URL in toast
+     * @default true
+     */
+    showUrl?: boolean;
+    /**
+     * Show HTTP method in toast
+     * @default true
+     */
+    showMethod?: boolean;
+}
+/**
+ * Network error specific config
+ */
+interface NetworkErrorConfig extends ErrorTypeConfig {
+    /**
+     * Show full URL in toast
+     * @default true
+     */
+    showUrl?: boolean;
+    /**
+     * Show HTTP method in toast
+     * @default true
+     */
+    showMethod?: boolean;
+    /**
+     * Show status code in toast
+     * @default true
+     */
+    showStatusCode?: boolean;
+}
+/**
+ * Centrifugo error specific config
+ */
+interface CentrifugoErrorConfig extends ErrorTypeConfig {
+    /**
+     * Show RPC method in toast
+     * @default true
+     */
+    showMethod?: boolean;
+    /**
+     * Show error code in toast
+     * @default true
+     */
+    showCode?: boolean;
+}
+/**
+ * Complete error tracking configuration
+ */
+interface ErrorTrackingConfig {
+    /**
+     * Validation error tracking configuration
+     */
+    validation?: ValidationErrorConfig;
+    /**
+     * CORS error tracking configuration
+     */
+    cors?: CORSErrorConfig;
+    /**
+     * Network error tracking configuration
+     */
+    network?: NetworkErrorConfig;
+    /**
+     * Centrifugo error tracking configuration
+     */
+    centrifugo?: CentrifugoErrorConfig;
+    /**
+     * Custom error handler (called before toast for all errors)
+     * Return false to prevent default toast notification
+     */
+    onError?: (error: ErrorDetail) => boolean | void;
+}
+/**
+ * Error tracking context value
+ */
+interface ErrorTrackingContextValue {
+    /** All errors */
+    errors: StoredError[];
+    /** Validation errors only */
+    validationErrors: StoredError<ValidationErrorDetail>[];
+    /** CORS errors only */
+    corsErrors: StoredError<CORSErrorDetail>[];
+    /** Network errors only */
+    networkErrors: StoredError<NetworkErrorDetail>[];
+    /** Centrifugo errors only */
+    centrifugoErrors: StoredError<CentrifugoErrorDetail>[];
+    /** Clear all errors */
+    clearErrors: () => void;
+    /** Clear errors by type */
+    clearErrorsByType: (type: 'validation' | 'cors' | 'network' | 'centrifugo') => void;
+    /** Clear specific error by ID */
+    clearError: (id: string) => void;
+    /** Get error count */
+    errorCount: number;
+    /** Get latest error */
+    latestError: StoredError | null;
+    /** Configuration */
+    config: {
+        validation: Required<ValidationErrorConfig>;
+        cors: Required<CORSErrorConfig>;
+        network: Required<NetworkErrorConfig>;
+        centrifugo: Required<CentrifugoErrorConfig>;
+    };
+}
+
+/**
+ * Error Handling Configuration Types
+ *
+ * Configuration types for ErrorTrackingProvider and ErrorBoundary
+ */
+
+/**
+ * Error Boundary Configuration
+ *
+ * Configuration for React ErrorBoundary component
+ */
+interface ErrorBoundaryConfig {
+    /** Enable error boundary (default: true) */
+    enabled?: boolean;
+    /** Support email to display in error UI */
+    supportEmail?: string;
+    /** Custom error handler called when error is caught */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+
+/**
+ * UI Component Types
+ *
+ * Types for layout UI components (navigation, footer, user menu)
+ */
+
+interface NavigationItem {
+    label: string;
+    href: string;
+    icon?: LucideIcon$1 | string;
+    badge?: string | number;
+    external?: boolean;
+}
+interface NavigationSection {
+    title?: string;
+    items: NavigationItem[];
+}
+interface FooterLink$1 {
+    label: string;
+    path: string;
+    external?: boolean;
+}
+interface FooterMenuSection$1 {
+    title: string;
+    items: FooterLink$1[];
+}
+interface FooterSocialLinks$1 {
+    github?: string;
+    linkedin?: string;
+    twitter?: string;
+    telegram?: string;
+    youtube?: string;
+    facebook?: string;
+    instagram?: string;
+    whatsapp?: string;
+    email?: string;
+}
+interface FooterConfig {
+    siteName?: string;
+    description?: string;
+    logo?: string;
+    badge?: {
+        icon: LucideIcon$1;
+        text: string;
+    };
+    socialLinks?: FooterSocialLinks$1;
+    links?: FooterLink$1[];
+    menuSections?: FooterMenuSection$1[];
+    copyright?: string;
+    credits?: {
+        text: string;
+        url?: string;
+    };
+    variant?: 'full' | 'simple';
+}
+interface UserMenuItem {
+    /** Menu item label */
+    label: string;
+    /** Link href (optional if onClick is provided) */
+    href?: string;
+    /** Icon component */
+    icon?: LucideIcon$1;
+    /** Visual variant */
+    variant?: 'default' | 'destructive';
+    /** Click handler (optional if href is provided) */
+    onClick?: () => void;
+    /** Open link in new tab */
+    external?: boolean;
+}
+interface UserMenuGroup {
+    /** Optional group title (renders DropdownMenuLabel) */
+    title?: string;
+    /** Menu items in this group */
+    items: UserMenuItem[];
+}
+interface UserMenuConfig {
+    /** Menu groups for authenticated users */
+    groups?: UserMenuGroup[];
+    /** Auth page path (for sign in button) */
+    authPath?: string;
+}
+
+/**
+ * Base Layout Types
+ *
+ * Core layout configuration that combines all provider configs
+ */
+
+/**
+ * Base Layout Props
+ *
+ * Core configuration for BaseApp component.
+ * All provider configs are imported from their respective modules.
+ */
+interface BaseLayoutProps {
+    children: ReactNode;
+    /** Theme configuration */
+    theme?: ThemeConfig;
+    /** Auth configuration */
+    auth?: AuthConfig;
+    /** Analytics configuration (from snippets/Analytics) */
+    analytics?: AnalyticsConfig;
+    /** Centrifugo configuration */
+    centrifugo?: CentrifugoConfig;
+    /** Error tracking configuration (from components/errors) */
+    errorTracking?: ErrorTrackingConfig;
+    /** SWR configuration */
+    swr?: SWRConfigOptions;
+    /** Error boundary configuration (from components/errors, enabled by default) */
+    errorBoundary?: ErrorBoundaryConfig;
+    /** MCP chat configuration */
+    mcpChat?: McpChatConfig;
+    /** PWA Install configuration (from snippets/PWAInstall) */
+    pwaInstall?: PwaInstallConfig;
+    /** Push Notifications configuration (from snippets/PushNotifications) */
+    pushNotifications?: PushNotificationsConfig;
+}
+
+interface UserMenuProps {
+    /** Display variant */
+    variant?: 'desktop' | 'mobile';
+    /** Menu groups for authenticated users */
+    groups?: UserMenuGroup[];
+    /** Auth page path (for sign in button) */
+    authPath?: string;
+}
+declare function UserMenu({ variant, groups, authPath, }: UserMenuProps): react_jsx_runtime.JSX.Element;
+
+type LayoutMode = 'public' | 'private' | 'admin';
+interface AppLayoutProps {
+    children: ReactNode;
+    /** Public layout component with enabled paths */
+    publicLayout?: {
+        component: React$1.ComponentType<{
+            children: ReactNode;
+        }>;
+        enabledPath?: string | string[];
+    };
+    /** Private layout component with enabled paths */
+    privateLayout?: {
+        component: React$1.ComponentType<{
+            children: ReactNode;
+        }>;
+        enabledPath?: string | string[];
+    };
+    /** Admin layout component with enabled paths */
+    adminLayout?: {
+        component: React$1.ComponentType<{
+            children: ReactNode;
+        }>;
+        enabledPath?: string | string[];
+    };
+    /**
+     * Paths that render without any layout wrapper (fullscreen pages)
+     * Providers (auth, theme, etc.) are still applied, only layout is skipped
+     * Useful for: fullscreen terminal, embed pages, print views
+     */
+    noLayoutPaths?: string | string[];
+    /** Theme configuration */
+    theme?: ThemeConfig;
+    /** Auth configuration */
+    auth?: AuthConfig;
+    /** Analytics configuration */
+    analytics?: AnalyticsConfig;
+    /** Centrifugo configuration */
+    centrifugo?: CentrifugoConfig;
+    /** Error tracking configuration */
+    errorTracking?: ErrorTrackingConfig;
+    /** SWR configuration */
+    swr?: SWRConfigOptions;
+    /** Error boundary configuration */
+    errorBoundary?: ErrorBoundaryConfig;
+    /** MCP Chat configuration */
+    mcpChat?: McpChatConfig;
+    /** PWA Install configuration */
+    pwaInstall?: PwaInstallConfig;
+    /** Push Notifications configuration */
+    pushNotifications?: PushNotificationsConfig;
+}
+/**
+ * AppLayout - Main Component with All Providers
+ */
+declare function AppLayout(props: AppLayoutProps): react_jsx_runtime.JSX.Element;
+
+type BaseAppProps = BaseLayoutProps;
+/**
+ * BaseApp - Core providers wrapper for any React/Next.js app
+ *
+ * Includes: ThemeProvider, TooltipProvider, SWRConfig, AuthProvider, AnalyticsProvider,
+ * CentrifugoProvider, PwaProvider, PushProvider, ErrorTrackingProvider,
+ * ErrorBoundary (optional), MCP Chat (optional)
+ * Also renders global Toaster and PageProgress components
+ */
+declare function BaseApp({ children, theme, auth, analytics, centrifugo, errorTracking, errorBoundary, swr, mcpChat, pwaInstall, pushNotifications, }: BaseAppProps): react_jsx_runtime.JSX.Element;
+
+interface PublicLayoutProps {
+    children: ReactNode;
+    /** Logo path or URL */
+    logo?: string;
+    /** Site name */
+    siteName?: string;
+    /** Navigation items */
+    navigation?: NavigationItem[];
+    /** User menu configuration (optional, uses useAuth() for authentication state) */
+    userMenu?: UserMenuConfig;
+}
+declare function PublicLayout({ children, logo, siteName, navigation, userMenu, }: PublicLayoutProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Public Footer Types
+ */
+
+interface FooterLink {
+    label: string;
+    path: string;
+    external?: boolean;
+}
+interface FooterMenuSection {
+    title: string;
+    items: FooterLink[];
+}
+interface FooterSocialLinks {
+    github?: string;
+    linkedin?: string;
+    twitter?: string;
+    telegram?: string;
+    youtube?: string;
+    facebook?: string;
+    instagram?: string;
+    whatsapp?: string;
+    email?: string;
+}
+interface PublicFooterProps {
+    /** Project name */
+    siteName: string;
+    /** Project description */
+    description?: string;
+    /** Logo path or URL */
+    logo?: string;
+    /** Optional badge */
+    badge?: {
+        icon: LucideIcon$1;
+        text: string;
+    };
+    /** Social media links */
+    socialLinks?: FooterSocialLinks;
+    /** Quick links (bottom bar) */
+    links?: FooterLink[];
+    /** Footer menu sections (desktop grid) */
+    menuSections?: FooterMenuSection[];
+    /** Copyright text (auto-generated if not provided) */
+    copyright?: string;
+    /** Credits */
+    credits?: {
+        text: string;
+        url?: string;
+    };
+    /** Variant: full (with all sections) or simple (minimal) */
+    variant?: 'full' | 'simple';
+}
+
+declare function PublicFooter({ siteName, description, logo, badge, socialLinks, links, menuSections, copyright: copyrightProp, credits: creditsProp, variant, }: PublicFooterProps): react_jsx_runtime.JSX.Element;
+
+interface FooterProjectInfoProps {
+    siteName: string;
+    description?: string;
+    logo?: string;
+    badge?: {
+        icon: LucideIcon$1;
+        text: string;
+    };
+    socialLinks?: FooterSocialLinks;
+    variant?: 'mobile' | 'desktop';
+}
+declare function FooterProjectInfo({ siteName, description, logo, badge, socialLinks, variant, }: FooterProjectInfoProps): react_jsx_runtime.JSX.Element;
+
+interface FooterMenuSectionsProps {
+    menuSections: FooterMenuSection[];
+}
+declare function FooterMenuSections({ menuSections }: FooterMenuSectionsProps): react_jsx_runtime.JSX.Element;
+
+interface FooterBottomProps {
+    copyright: string;
+    credits?: {
+        text: string;
+        url?: string;
+    };
+    links?: FooterLink[];
+    variant?: 'mobile' | 'desktop';
+}
+declare function FooterBottom({ copyright, credits, links, variant, }: FooterBottomProps): react_jsx_runtime.JSX.Element;
+
+interface FooterSocialLinksProps {
+    socialLinks?: FooterSocialLinks;
+    className?: string;
+    iconClassName?: string;
+}
+declare function FooterSocialLinksComponent({ socialLinks, className, iconClassName, }: FooterSocialLinksProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * DjangoCFG Logo Component
+ *
+ * Default SVG logo for DjangoCFG
+ */
+interface DjangoCFGLogoProps {
+    className?: string;
+    size?: number;
+}
+declare function DjangoCFGLogo({ className, size }: DjangoCFGLogoProps): react_jsx_runtime.JSX.Element;
+
+interface SidebarItem {
+    label: string;
+    href: string;
+    icon?: string | LucideIcon$1;
+    badge?: string | number;
+}
+interface SidebarConfig {
+    items: SidebarItem[];
+    homeHref?: string;
+}
+interface HeaderConfig {
+    title?: string;
+    /** User menu groups */
+    groups?: UserMenuConfig['groups'];
+    /** Auth page path (for sign in button) */
+    authPath?: string;
+}
+interface PrivateLayoutProps {
+    children: ReactNode;
+    /** Sidebar configuration */
+    sidebar?: SidebarConfig;
+    /** Header configuration */
+    header?: HeaderConfig;
+    /** Content padding */
+    contentPadding?: 'none' | 'default';
+}
+declare function PrivateLayout({ children, sidebar, header, contentPadding, }: PrivateLayoutProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Auth Layout
+ *
+ * Layout for authentication pages with OTP (email/phone), OAuth (GitHub), and 2FA support.
+ * Supports multi-step authentication flow: identifier → OTP → 2FA (if enabled)
+ */
+
+declare const AuthLayout: React$1.FC<AuthLayoutProps>;
+
+declare const AuthFormProvider: React$1.FC<AuthLayoutProps>;
+declare const useAuthFormContext: () => AuthFormContextType;
+
+declare const IdentifierForm: React$1.FC;
+
+declare const OTPForm: React$1.FC;
+
+declare const AuthHelp: React$1.FC<AuthHelpProps>;
+
+/**
+ * OAuth Providers Component
+ *
+ * Shows OAuth login buttons (GitHub, etc.) when enabled.
+ */
+declare const OAuthProviders: React$1.FC;
+
+interface OAuthCallbackProps {
+    onSuccess?: (user: any, isNewUser: boolean, provider: string) => void;
+    onError?: (error: string) => void;
+    redirectUrl?: string;
+}
+/**
+ * OAuth Callback Handler Component
+ *
+ * Processes OAuth callback from providers (GitHub, etc.).
+ * Reads code, state, and provider from URL params and exchanges for tokens.
+ *
+ * Usage:
+ * Place this component on your /auth page to handle OAuth callbacks.
+ *
+ * @example
+ * ```tsx
+ * // app/auth/page.tsx
+ * import { OAuthCallback, AuthLayout } from '@djangocfg/layouts';
+ *
+ * export default function AuthPage() {
+ *   return (
+ *     <>
+ *       <OAuthCallback
+ *         onSuccess={(user) => console.log('OAuth success:', user)}
+ *         onError={(error) => console.error('OAuth error:', error)}
+ *       />
+ *       <AuthLayout enableGithubAuth>
+ *         {/* Your auth content *\/}
+ *       </AuthLayout>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare const OAuthCallback: React$1.FC<OAuthCallbackProps>;
+
+interface AdminLayoutProps extends PrivateLayoutProps {
+    children: ReactNode;
+}
+/**
+ * Admin Layout Component
+ *
+ * Wrapper around PrivateLayout with admin-specific defaults
+ * Same API as PrivateLayout - just a convenience export
+ */
+declare function AdminLayout(props: AdminLayoutProps): react_jsx_runtime.JSX.Element;
+
+interface ProfileLayoutProps {
+    onUnauthenticated?: () => void;
+    title?: string;
+    enable2FA?: boolean;
+    enableDeleteAccount?: boolean;
+}
+declare const ProfileLayout: React$1.FC<ProfileLayoutProps>;
+
+interface BreadcrumbItem {
+    path: string;
+    label: string;
+    isActive: boolean;
+}
+declare function generateBreadcrumbsFromPath(pathname: string): BreadcrumbItem[];
+
+declare const DIALOG_EVENTS: {
+    readonly OPEN_AUTH_DIALOG: "OPEN_AUTH_DIALOG";
+    readonly CLOSE_AUTH_DIALOG: "CLOSE_AUTH_DIALOG";
+    readonly AUTH_SUCCESS: "AUTH_SUCCESS";
+    readonly AUTH_FAILURE: "AUTH_FAILURE";
+};
+interface AuthDialogProps {
+    onAuthRequired?: () => void;
+    authPath?: string;
+}
+declare const AuthDialog: React$1.FC<AuthDialogProps>;
+
+declare const AUTH_EVENTS: {
+    readonly OPEN_AUTH_DIALOG: "OPEN_AUTH_DIALOG";
+    readonly CLOSE_AUTH_DIALOG: "CLOSE_AUTH_DIALOG";
+    readonly AUTH_SUCCESS: "AUTH_SUCCESS";
+    readonly AUTH_FAILURE: "AUTH_FAILURE";
+};
+type AuthEventType = typeof AUTH_EVENTS[keyof typeof AUTH_EVENTS];
+interface OpenAuthDialogPayload {
+    message?: string;
+    redirectUrl?: string;
+}
+interface AuthSuccessPayload {
+    user?: any;
+}
+interface AuthFailurePayload {
+    error?: string;
+}
+
+/**
+ * Hook to control auth dialog from anywhere in the app
+ */
+declare function useAuthDialog(): {
+    openAuthDialog: (options?: OpenAuthDialogPayload) => void;
+    closeAuthDialog: () => void;
+};
+
+/**
+ * useAnalytics Hook
+ *
+ * Provides Google Analytics tracking via react-ga4
+ * Automatically tracks page views on route changes
+ * Only works in production mode
+ */
+/**
+ * Analytics utility object for standalone usage (outside React components)
+ *
+ * @example
+ * ```ts
+ * import { Analytics } from '@djangocfg/layouts';
+ *
+ * // In an event handler or utility function
+ * Analytics.event('button_click', { category: 'engagement', label: 'signup' });
+ * ```
+ */
+declare const Analytics: {
+    /**
+     * Initialize Google Analytics (called automatically by useAnalytics hook)
+     */
+    init: (trackingId: string) => void;
+    /**
+     * Check if Analytics is enabled and initialized
+     */
+    isEnabled: () => boolean;
+    /**
+     * Track a page view
+     */
+    pageview: (path: string) => void;
+    /**
+     * Track a custom event
+     * @param name - Event name (action)
+     * @param params - Optional event parameters
+     */
+    event: (name: string, params?: Record<string, any>) => void;
+    /**
+     * Set user ID for tracking
+     */
+    setUser: (userId: string) => void;
+    /**
+     * Set custom dimensions/metrics
+     */
+    set: (fieldsObject: Record<string, any>) => void;
+};
+/**
+ * Hook for Google Analytics tracking via react-ga4
+ *
+ * Automatically initializes GA and tracks page views on route changes
+ * Only works in production mode (NODE_ENV === 'production')
+ *
+ * @example
+ * ```tsx
+ * // Just call the hook - it auto-tracks pageviews
+ * useAnalytics();
+ *
+ * // Or use the returned methods for custom tracking
+ * const { event, isEnabled } = useAnalytics();
+ * event('button_click', { category: 'engagement', label: 'signup' });
+ * ```
+ */
+declare function useAnalytics(trackingIdProp?: string): {
+    isEnabled: boolean;
+    trackingId: string;
+    pageview: (path: string) => void;
+    event: (name: string, params?: Record<string, any>) => void;
+    setUser: (userId: string) => void;
+    set: (fieldsObject: Record<string, any>) => void;
+};
+
+interface AnalyticsProviderProps {
+    children: ReactNode;
+    /** Google Analytics tracking ID (optional if using AppContext) */
+    trackingId?: string;
+}
+/**
+ * Analytics Provider that initializes tracking
+ * Automatically:
+ * - Initializes GA4 with tracking ID from prop or config
+ * - Sets user ID when authenticated
+ * - Tracks page views on route changes
+ */
+declare function AnalyticsProvider({ children, trackingId }: AnalyticsProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Analytics Events Constants
+ *
+ * Predefined event names and categories for consistent tracking
+ * across the entire application.
+ */
+/**
+ * Event Categories
+ */
+declare const AnalyticsCategory: {
+    readonly AUTH: "auth";
+    readonly ERROR: "error";
+    readonly NAVIGATION: "navigation";
+    readonly ENGAGEMENT: "engagement";
+    readonly USER: "user";
+};
+/**
+ * Predefined Event Names
+ */
+declare const AnalyticsEvent: {
+    readonly AUTH_OTP_REQUEST: "auth_otp_request";
+    readonly AUTH_OTP_VERIFY_SUCCESS: "auth_otp_verify_success";
+    readonly AUTH_OTP_VERIFY_FAIL: "auth_otp_verify_fail";
+    readonly AUTH_LOGIN_SUCCESS: "auth_login_success";
+    readonly AUTH_LOGOUT: "auth_logout";
+    readonly AUTH_SESSION_EXPIRED: "auth_session_expired";
+    readonly AUTH_TOKEN_REFRESH: "auth_token_refresh";
+    readonly AUTH_TOKEN_REFRESH_FAIL: "auth_token_refresh_fail";
+    readonly AUTH_OAUTH_START: "auth_oauth_start";
+    readonly AUTH_OAUTH_SUCCESS: "auth_oauth_success";
+    readonly AUTH_OAUTH_FAIL: "auth_oauth_fail";
+    readonly ERROR_BOUNDARY: "error_boundary";
+    readonly ERROR_API: "error_api";
+    readonly ERROR_VALIDATION: "error_validation";
+    readonly ERROR_NETWORK: "error_network";
+    readonly NAV_ADMIN_ENTER: "nav_admin_enter";
+    readonly NAV_DASHBOARD_ENTER: "nav_dashboard_enter";
+    readonly NAV_PAGE_VIEW: "nav_page_view";
+    readonly THEME_CHANGE: "theme_change";
+    readonly SIDEBAR_TOGGLE: "sidebar_toggle";
+    readonly MOBILE_MENU_OPEN: "mobile_menu_open";
+    readonly USER_PROFILE_VIEW: "user_profile_view";
+    readonly USER_PROFILE_UPDATE: "user_profile_update";
+};
+type AnalyticsCategoryType = typeof AnalyticsCategory[keyof typeof AnalyticsCategory];
+type AnalyticsEventType = typeof AnalyticsEvent[keyof typeof AnalyticsEvent];
+
+/**
+ * Types for @djangocfg/mcp-chat
+ */
+
+/**
+ * AI Chat message role
+ */
+type AIMessageRole = 'user' | 'assistant' | 'system';
+/**
+ * AI Chat message
+ */
+interface AIChatMessage {
+    id: string;
+    role: AIMessageRole;
+    content: string;
+    timestamp: Date;
+    /** Related documentation links */
+    sources?: AIChatSource[];
+    /** Is message still being generated */
+    isStreaming?: boolean;
+}
+/**
+ * AI Documentation source reference
+ */
+interface AIChatSource {
+    title: string;
+    path: string;
+    url?: string;
+    section?: string;
+    score?: number;
+}
+/**
+ * Chat display mode
+ * - closed: Only FAB button visible
+ * - floating: Floating panel (default)
+ * - sidebar: Full-height sidebar on the right (desktop only)
+ */
+type ChatDisplayMode = 'closed' | 'floating' | 'sidebar';
+/**
+ * Chat widget configuration
+ */
+interface ChatWidgetConfig {
+    /** API endpoint for chat (default: /api/chat) */
+    apiEndpoint?: string;
+    /** Widget title */
+    title?: string;
+    /** Placeholder text for input */
+    placeholder?: string;
+    /** Initial greeting message */
+    greeting?: string;
+    /** Position on screen */
+    position?: 'bottom-right' | 'bottom-left';
+    /** Theme variant */
+    variant?: 'default' | 'minimal';
+    /** Auto-detect environment (dev/prod) for API endpoint. If false (default), always uses production */
+    autoDetectEnvironment?: boolean;
+}
+/**
+ * AI Chat API response
+ */
+interface AIChatApiResponse {
+    success: boolean;
+    content?: string;
+    sources?: Array<{
+        id?: string;
+        title: string;
+        path: string;
+        url?: string;
+        section?: string;
+        score?: number;
+    }>;
+    threadId?: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    error?: string;
+}
+/**
+ * useAIChat hook options
+ */
+interface UseAIChatOptions {
+    /** API endpoint (default: /api/ai/chat) */
+    apiEndpoint?: string;
+    /** Initial messages */
+    initialMessages?: AIChatMessage[];
+    /** Callback on error */
+    onError?: (error: Error) => void;
+    /** Enable streaming responses (default: true) */
+    enableStreaming?: boolean;
+    /** Thread ID for conversation (generated if not provided) */
+    threadId?: string;
+    /** User ID for conversation (generated if not provided) */
+    userId?: string;
+}
+/**
+ * useAIChat hook return type
+ */
+interface UseAIChatReturn {
+    messages: AIChatMessage[];
+    isLoading: boolean;
+    error: Error | null;
+    threadId: string;
+    userId: string;
+    sendMessage: (content: string) => Promise<void>;
+    clearMessages: () => void;
+    stopStreaming: () => void;
+}
+/**
+ * Context type for chat messages triggered from different parts of the app
+ */
+type McpChatContextType = 'error' | 'question' | 'explain' | 'advice' | 'help' | 'custom';
+/**
+ * Event detail for mcp:chat:send custom event
+ */
+interface McpChatEventDetail {
+    /** Message to send to chat */
+    message: string;
+    /** Optional context about the message */
+    context?: {
+        /** Type of context */
+        type?: McpChatContextType;
+        /** Additional data (error object, selected element, etc.) */
+        data?: Record<string, any>;
+        /** Source component/page that triggered the event */
+        source?: string;
+    };
+    /** Auto-send message after opening chat (default: true) */
+    autoSend?: boolean;
+    /** Open chat in specific mode (default: 'floating') */
+    displayMode?: ChatDisplayMode;
+}
+/**
+ * useMcpChat hook return type
+ */
+interface UseMcpChatReturn {
+    /** Send message to chat from anywhere in the app */
+    sendToChat: (detail: McpChatEventDetail) => void;
+    /** Check if chat is available */
+    isChatAvailable: () => boolean;
+}
+
+interface AIChatWidgetProps extends ChatWidgetConfig {
+    /** Custom class name for the container */
+    className?: string;
+    /** Enable streaming responses (default: true) */
+    enableStreaming?: boolean;
+}
+/**
+ * AI Chat Widget component
+ *
+ * AI-powered documentation assistant with streaming support.
+ * Uses Mastra agent backend for intelligent responses.
+ *
+ * Can be used in two ways:
+ * 1. Standalone (wraps itself in AIChatProvider)
+ * 2. Inside an AIChatProvider (uses context directly)
+ *
+ * @example
+ * ```tsx
+ * // Standalone usage (always uses production API)
+ * <AIChatWidget />
+ *
+ * // Auto-detect environment (dev/prod)
+ * <AIChatWidget autoDetectEnvironment={true} />
+ *
+ * // With provider for custom control
+ * <AIChatProvider apiEndpoint="/api/ai/chat">
+ *   <MyApp />
+ *   <AIChatWidget />
+ * </AIChatProvider>
+ * ```
+ */
+declare const AIChatWidget: React$1.FC<AIChatWidgetProps>;
+
+declare const ChatPanel: React$1.MemoExoticComponent<() => react_jsx_runtime.JSX.Element>;
+
+interface MessageBubbleProps {
+    message: AIChatMessage;
+    isCompact?: boolean;
+}
+declare const MessageBubble: React$1.NamedExoticComponent<MessageBubbleProps>;
+
+interface AIMessageInputProps {
+    onSend: (message: string) => void;
+    disabled?: boolean;
+    isLoading?: boolean;
+    placeholder?: string;
+    maxRows?: number;
+}
+declare const AIMessageInput: React$1.NamedExoticComponent<AIMessageInputProps>;
+
+interface AskAIButtonProps extends Omit<ButtonProps, 'onClick'> {
+    /** Message to send to AI */
+    message: string;
+    /** Additional context data */
+    contextData?: Record<string, any>;
+    /** Source component name */
+    source?: string;
+    /** Auto-send message (default: true) */
+    autoSend?: boolean;
+    /** Show icon (default: true) */
+    showIcon?: boolean;
+    /** Callback after sending */
+    onSent?: () => void;
+}
+/**
+ * Universal AI chat trigger button
+ *
+ * @example Basic usage
+ * ```tsx
+ * <AskAIButton message="Explain this feature">
+ *   Explain this
+ * </AskAIButton>
+ * ```
+ *
+ * @example With context
+ * ```tsx
+ * <AskAIButton
+ *   message="Why is this failing?"
+ *   contextData={{ error: error.stack }}
+ *   source="ErrorBoundary"
+ * >
+ *   Ask AI
+ * </AskAIButton>
+ * ```
+ */
+declare function AskAIButton({ message, contextData, source, autoSend, showIcon, onSent, children, variant, size, className, ...buttonProps }: AskAIButtonProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * AI Chat context state
+ */
+interface AIChatContextState {
+    /** All chat messages */
+    messages: AIChatMessage[];
+    /** Whether a request is in progress */
+    isLoading: boolean;
+    /** Last error if any */
+    error: Error | null;
+    /** Whether chat panel is open */
+    isOpen: boolean;
+    /** Whether chat is minimized */
+    isMinimized: boolean;
+    /** Configuration */
+    config: ChatWidgetConfig;
+    /** Current display mode */
+    displayMode: ChatDisplayMode;
+    /** Is on mobile device */
+    isMobile: boolean;
+    /** Thread ID for conversation */
+    threadId: string;
+    /** User ID for conversation */
+    userId: string;
+}
+/**
+ * AI Chat context actions
+ */
+interface AIChatContextActions {
+    /** Send a message */
+    sendMessage: (content: string) => Promise<void>;
+    /** Clear all messages */
+    clearMessages: () => void;
+    /** Open chat panel */
+    openChat: () => void;
+    /** Close chat panel */
+    closeChat: () => void;
+    /** Toggle chat panel */
+    toggleChat: () => void;
+    /** Minimize/restore chat */
+    toggleMinimize: () => void;
+    /** Set display mode */
+    setDisplayMode: (mode: ChatDisplayMode) => void;
+    /** Stop streaming response */
+    stopStreaming: () => void;
+}
+type AIChatContextValue = AIChatContextState & AIChatContextActions;
+/**
+ * AI Chat provider props
+ */
+interface AIChatProviderProps {
+    children: ReactNode;
+    /** API endpoint for AI chat (default: /api/ai/chat) */
+    apiEndpoint?: string;
+    /** Widget configuration */
+    config?: Partial<ChatWidgetConfig>;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+    /** Enable streaming (default: true) */
+    enableStreaming?: boolean;
+}
+/**
+ * AI Chat provider component
+ * Uses useAIChat hook with server-side persistence
+ */
+declare function AIChatProvider({ children, apiEndpoint, config: userConfig, onError, enableStreaming, }: AIChatProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access AI chat context
+ */
+declare function useAIChatContext(): AIChatContextValue;
+/**
+ * Hook to check if AI chat context is available
+ */
+declare function useAIChatContextOptional(): AIChatContextValue | null;
+
+/**
+ * AI Chat hook with streaming support and server-side history
+ * All persistence is handled through API endpoints - no localStorage
+ */
+declare function useAIChat(options: UseAIChatOptions): UseAIChatReturn;
+
+/**
+ * Configuration for chat layout management
+ */
+interface ChatLayoutConfig {
+    /** Initial width of sidebar in pixels */
+    initialWidth?: number;
+    /** Animation duration in ms */
+    animationDuration?: number;
+    /** Element to push (defaults to body) */
+    pushTarget?: 'body' | 'main' | string;
+}
+/**
+ * Return type for useChatLayout hook
+ */
+interface UseChatLayoutReturn {
+    /** Current sidebar width */
+    sidebarWidth: number;
+    /** Apply layout changes for mode */
+    applyLayout: (mode: ChatDisplayMode) => void;
+    /** Reset layout to default */
+    resetLayout: () => void;
+    /** Update sidebar width (for resize) */
+    updateWidth: (width: number) => void;
+    /** Start resize operation */
+    startResize: (e: React.MouseEvent) => void;
+    /** Whether currently resizing */
+    isResizing: boolean;
+    /** Get CSS for sidebar container */
+    getSidebarStyles: () => React.CSSProperties;
+    /** Get CSS for floating container */
+    getFloatingStyles: (position: 'bottom-right' | 'bottom-left') => React.CSSProperties;
+    /** Get CSS for FAB button */
+    getFabStyles: (position: 'bottom-right' | 'bottom-left') => React.CSSProperties;
+}
+/**
+ * Hook for managing chat layout embedding modes
+ *
+ * Handles:
+ * - Sidebar mode: pushes content left by adding margin to target element
+ *   AND automatically adjusts all position:fixed elements with right:0
+ * - Floating mode: positions chat at bottom-right/left
+ * - Closed mode: just shows FAB button
+ *
+ * @example
+ * ```tsx
+ * const { applyLayout, getSidebarStyles, getFloatingStyles } = useChatLayout({
+ *   sidebarWidth: 400,
+ * });
+ *
+ * useEffect(() => {
+ *   applyLayout(displayMode);
+ * }, [displayMode]);
+ * ```
+ */
+declare function useChatLayout(config?: ChatLayoutConfig): UseChatLayoutReturn;
+
+/**
+ * Hook to send messages to MCP Chat from anywhere in the app
+ *
+ * @example
+ * ```tsx
+ * function ErrorBoundary({ error }) {
+ *   const { sendToChat } = useMcpChat();
+ *
+ *   const explainError = () => {
+ *     sendToChat({
+ *       message: `Explain this error: ${error.message}`,
+ *       context: {
+ *         type: 'error',
+ *         data: { error: error.stack },
+ *         source: 'ErrorBoundary'
+ *       }
+ *     });
+ *   };
+ *
+ *   return <button onClick={explainError}>Explain Error</button>;
+ * }
+ * ```
+ */
+declare function useMcpChat(): UseMcpChatReturn;
+
+interface PwaContextValue {
+    isIOS: boolean;
+    isAndroid: boolean;
+    isDesktop: boolean;
+    isSafari: boolean;
+    isChrome: boolean;
+    isFirefox: boolean;
+    isEdge: boolean;
+    isOpera: boolean;
+    isBrave: boolean;
+    isArc: boolean;
+    isVivaldi: boolean;
+    isYandex: boolean;
+    isSamsungBrowser: boolean;
+    isUCBrowser: boolean;
+    isChromium: boolean;
+    browserName: string;
+    isInstalled: boolean;
+    canPrompt: boolean;
+    install: () => Promise<InstallOutcome>;
+}
+interface PwaConfig {
+    enabled?: boolean;
+}
+declare function PwaProvider({ children, ...config }: PwaConfig & {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Use install context
+ * Must be used within <PwaProvider>
+ */
+declare function useInstall(): PwaContextValue;
+
+interface A2HSHintProps {
+    /**
+     * Additional class names for the container
+     */
+    className?: string;
+    /**
+     * Number of days before re-showing dismissed hint
+     * @default 3
+     * Set to null to never reset (show once forever)
+     */
+    resetAfterDays?: number | null;
+    /**
+     * Delay before showing hint (ms)
+     * @default 3000
+     */
+    delayMs?: number;
+    /**
+     * Demo mode - shows hint on all platforms with appropriate guides
+     * Production: only iOS Safari & Android Chrome
+     * Demo: shows on desktop too with desktop install guide
+     * @default false
+     */
+    demo?: boolean;
+    /**
+     * App logo URL to display in hint
+     * If not provided, uses Share icon
+     */
+    logo?: string;
+}
+declare function A2HSHint({ className, resetAfterDays, delayMs, demo, logo, }?: A2HSHintProps): react_jsx_runtime.JSX.Element;
+
+declare function IOSGuide(props: IOSGuideModalProps): react_jsx_runtime.JSX.Element;
+
+declare function DesktopGuide({ onDismiss, open }: IOSGuideModalProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Options for useIsPWA hook
+ */
+interface UseIsPWAOptions {
+    /**
+     * Use reliable check with additional validation for desktop browsers
+     * This prevents false positives on Safari macOS "Add to Dock"
+     * @default false
+     */
+    reliable?: boolean;
+}
+/**
+ * Hook to detect if app is running as PWA (standalone mode)
+ *
+ * @param options - Configuration options
+ * @returns true if app is running as PWA
+ */
+declare function useIsPWA(options?: UseIsPWAOptions): boolean;
+/**
+ * Clear isPWA cache
+ *
+ * Useful for testing or when you want to force a re-check
+ *
+ * @example
+ * ```typescript
+ * import { clearIsPWACache } from '@djangocfg/layouts/snippets';
+ * clearIsPWACache();
+ * window.location.reload();
+ * ```
+ */
+declare function clearIsPWACache(): void;
+
+/**
+ * Platform Detection Utilities
+ *
+ * Centralized utilities for detecting PWA state, platform, and capabilities.
+ * Used by hooks to avoid code duplication.
+ */
+/**
+ * Check if running as PWA (standalone mode)
+ *
+ * Checks if the app is running in standalone mode (added to home screen).
+ * This is the primary indicator that a PWA has been installed.
+ *
+ * @returns true if app is running in standalone mode
+ *
+ * @example
+ * ```typescript
+ * if (isStandalone()) {
+ *   console.log('Running as PWA');
+ * }
+ * ```
+ */
+declare function isStandalone(): boolean;
+/**
+ * Check if device is mobile
+ *
+ * @returns true if device is mobile (iOS, Android, etc.)
+ */
+declare function isMobileDevice(): boolean;
+/**
+ * Check if web app manifest exists and is valid
+ *
+ * @returns true if manifest link exists in document head
+ */
+declare function hasValidManifest(): boolean;
+/**
+ * Reliable check for PWA mode with edge case handling
+ *
+ * This function provides additional validation for desktop browsers
+ * to avoid false positives (e.g., Safari macOS "Add to Dock").
+ *
+ * For mobile devices, standard standalone check is sufficient.
+ * For desktop, additionally validates that a manifest exists.
+ *
+ * @returns true if app is running as a genuine PWA
+ *
+ * @example
+ * ```typescript
+ * // Use this for more reliable detection
+ * if (isStandaloneReliable()) {
+ *   console.log('Definitely running as PWA');
+ * }
+ * ```
+ */
+declare function isStandaloneReliable(): boolean;
+/**
+ * Get display mode from media query
+ *
+ * @returns Current display mode: 'standalone', 'fullscreen', 'minimal-ui', or 'browser'
+ */
+declare function getDisplayMode(): 'standalone' | 'fullscreen' | 'minimal-ui' | 'browser';
+/**
+ * Create a media query listener for display-mode changes
+ *
+ * @param callback - Function to call when display mode changes
+ * @returns Cleanup function to remove listener
+ *
+ * @example
+ * ```typescript
+ * const cleanup = onDisplayModeChange((isStandalone) => {
+ *   console.log('Display mode changed:', isStandalone);
+ * });
+ *
+ * // Later: cleanup();
+ * ```
+ */
+declare function onDisplayModeChange(callback: (isStandalone: boolean) => void): () => void;
+
+/**
+ * LocalStorage utilities for PWA install state persistence
+ */
+
+/**
+ * Clear all PWA install data
+ */
+declare function clearAllPWAInstallData(): void;
+
+interface PushMessage {
+    id: string;
+    title: string;
+    body: string;
+    icon?: string;
+    badge?: string;
+    tag?: string;
+    timestamp: number;
+    data?: Record<string, unknown>;
+}
+interface DjangoPushContextValue {
+    isSupported: boolean;
+    permission: NotificationPermission;
+    isSubscribed: boolean;
+    subscription: PushSubscription | null;
+    isLoading: boolean;
+    error: Error | null;
+    pushes: PushMessage[];
+    subscribe: () => Promise<boolean>;
+    unsubscribe: () => Promise<boolean>;
+    sendTestPush: (message: {
+        title: string;
+        body: string;
+        url?: string;
+    }) => Promise<boolean>;
+    sendPush: (message: Omit<PushMessage, 'id' | 'timestamp'>) => Promise<void>;
+    clearPushes: () => void;
+    removePush: (id: string) => void;
+}
+interface DjangoPushProviderProps extends PushNotificationOptions {
+    children: React$1.ReactNode;
+    /**
+     * Auto-subscribe on mount if permission granted
+     * @default false
+     */
+    autoSubscribe?: boolean;
+    /**
+     * Callback when subscription created
+     */
+    onSubscribed?: (subscription: PushSubscription) => void;
+    /**
+     * Callback when subscription failed
+     */
+    onSubscribeError?: (error: Error) => void;
+    /**
+     * Callback when unsubscribed
+     */
+    onUnsubscribed?: () => void;
+}
+/**
+ * Provider for Django push notifications
+ */
+declare function DjangoPushProvider({ children, vapidPublicKey, autoSubscribe, onSubscribed, onSubscribeError, onUnsubscribed, }: DjangoPushProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access Django push context
+ */
+declare function useDjangoPushContext(): DjangoPushContextValue;
+
+interface PushPromptProps extends PushNotificationOptions {
+    /**
+     * Only show if PWA is installed
+     * @default true
+     */
+    requirePWA?: boolean;
+    /**
+     * Delay before showing prompt (ms)
+     * @default 5000
+     */
+    delayMs?: number;
+    /**
+     * Number of days before re-showing dismissed prompt
+     * @default 7
+     */
+    resetAfterDays?: number;
+    /**
+     * Callback when push is enabled
+     */
+    onEnabled?: () => void;
+    /**
+     * Callback when push is dismissed
+     */
+    onDismissed?: () => void;
+}
+declare function PushPrompt({ vapidPublicKey, subscribeEndpoint, requirePWA, delayMs, resetAfterDays, onEnabled, onDismissed, }: PushPromptProps): react_jsx_runtime.JSX.Element;
+
+declare function usePushNotifications(options?: PushNotificationOptions): {
+    subscribe: () => Promise<PushSubscription | null>;
+    unsubscribe: () => Promise<boolean>;
+    isSupported: boolean;
+    permission: NotificationPermission;
+    isSubscribed: boolean;
+    subscription: PushSubscription | null;
+};
+
+interface UseDjangoPushOptions extends PushNotificationOptions {
+    /**
+     * Callback when subscription created
+     */
+    onSubscribed?: (subscription: PushSubscription) => void;
+    /**
+     * Callback when subscription failed
+     */
+    onSubscribeError?: (error: Error) => void;
+    /**
+     * Callback when unsubscribed
+     */
+    onUnsubscribed?: () => void;
+}
+interface UseDjangoPushReturn {
+    isSupported: boolean;
+    permission: NotificationPermission;
+    isSubscribed: boolean;
+    subscription: PushSubscription | null;
+    isLoading: boolean;
+    error: Error | null;
+    subscribe: () => Promise<boolean>;
+    unsubscribe: () => Promise<boolean>;
+    sendTestPush: (message: {
+        title: string;
+        body: string;
+        url?: string;
+    }) => Promise<boolean>;
+}
+/**
+ * Hook for Django-CFG push notifications integration
+ */
+declare function useDjangoPush(options: UseDjangoPushOptions): UseDjangoPushReturn;
+
+/**
+ * Push Notifications Configuration
+ *
+ * Centralized constants for push notifications functionality.
+ *
+ * SECURITY NOTE:
+ * - VAPID_PRIVATE_KEY should NEVER be in frontend code
+ * - Private keys must only exist in backend/API routes
+ * - Frontend only needs the public key (NEXT_PUBLIC_* env vars)
+ * - VAPID_MAILTO should also remain on backend only
+ */
+declare const DEFAULT_VAPID_PUBLIC_KEY: string;
+
+/**
+ * VAPID Key Utilities
+ *
+ * Provides validation and conversion utilities for VAPID public keys
+ * used in push notification subscriptions.
+ *
+ * VAPID keys must be:
+ * - Base64url encoded
+ * - 65 bytes after decoding (P-256 uncompressed public key)
+ * - Start with 0x04 (uncompressed point indicator)
+ */
+/**
+ * Custom error class for VAPID key validation failures
+ */
+declare class VapidKeyError extends Error {
+    readonly code: VapidKeyErrorCode;
+    constructor(message: string, code: VapidKeyErrorCode);
+}
+/**
+ * Error codes for VAPID key validation
+ */
+type VapidKeyErrorCode = 'VAPID_EMPTY' | 'VAPID_INVALID_TYPE' | 'VAPID_INVALID_BASE64' | 'VAPID_INVALID_LENGTH' | 'VAPID_INVALID_FORMAT';
+/**
+ * Convert base64url VAPID public key to Uint8Array
+ *
+ * Validates and converts a VAPID public key from base64url format
+ * to Uint8Array for use with PushManager.subscribe().
+ *
+ * @param base64String - VAPID public key in base64url format
+ * @returns Uint8Array ready for pushManager.subscribe()
+ * @throws VapidKeyError if key is invalid
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const key = urlBase64ToUint8Array(process.env.NEXT_PUBLIC_VAPID_PUBLIC_KEY);
+ *   await registration.pushManager.subscribe({
+ *     userVisibleOnly: true,
+ *     applicationServerKey: key,
+ *   });
+ * } catch (e) {
+ *   if (e instanceof VapidKeyError) {
+ *     console.error('Invalid VAPID key:', e.message, e.code);
+ *   }
+ * }
+ * ```
+ */
+declare function urlBase64ToUint8Array(base64String: string): Uint8Array;
+/**
+ * Validate VAPID key without conversion
+ *
+ * Checks if a VAPID key is valid without converting it.
+ * Useful for validation before attempting subscription.
+ *
+ * @param base64String - VAPID public key to validate
+ * @returns true if key is valid
+ *
+ * @example
+ * ```typescript
+ * if (isValidVapidKey(vapidKey)) {
+ *   // Proceed with subscription
+ * } else {
+ *   console.error('Invalid VAPID key configuration');
+ * }
+ * ```
+ */
+declare function isValidVapidKey(base64String: string): boolean;
+/**
+ * Get VAPID key information for debugging
+ *
+ * Returns detailed information about a VAPID key for troubleshooting.
+ *
+ * @param base64String - VAPID public key to inspect
+ * @returns Key information object
+ *
+ * @example
+ * ```typescript
+ * const info = getVapidKeyInfo(process.env.NEXT_PUBLIC_VAPID_PUBLIC_KEY);
+ * console.log('VAPID Key Info:', info);
+ * // {
+ * //   valid: true,
+ * //   length: 65,
+ * //   firstByte: '0x04',
+ * //   format: 'P-256 uncompressed'
+ * // }
+ * ```
+ */
+declare function getVapidKeyInfo(base64String: string): {
+    valid: boolean;
+    length?: number;
+    firstByte?: string;
+    format?: string;
+    error?: string;
+    errorCode?: VapidKeyErrorCode;
+};
+/**
+ * Safe VAPID key conversion with error handling
+ *
+ * Attempts to convert a VAPID key with detailed error logging.
+ * Returns null on failure instead of throwing.
+ *
+ * @param base64String - VAPID public key
+ * @param onError - Optional error callback
+ * @returns Uint8Array or null if conversion fails
+ *
+ * @example
+ * ```typescript
+ * const key = safeUrlBase64ToUint8Array(vapidKey, (error) => {
+ *   console.error('VAPID conversion failed:', error.message, error.code);
+ * });
+ *
+ * if (key) {
+ *   // Use key for subscription
+ * }
+ * ```
+ */
+declare function safeUrlBase64ToUint8Array(base64String: string, onError?: (error: VapidKeyError) => void): Uint8Array | null;
+
+/**
+ * Clear all push notification data
+ */
+declare function clearAllPushData(): void;
+
+interface ClientOnlyProps {
+    children: ReactNode;
+    /**
+     * Fallback to show during SSR and initial mount
+     * @default Preloader with "Loading..." text
+     */
+    fallback?: ReactNode;
+}
+/**
+ * ClientOnly - Prevents SSR hydration mismatch
+ *
+ * Use this to wrap components that:
+ * - Access browser-only APIs (window, localStorage, etc.)
+ * - Have different initial state on server vs client
+ * - Use authentication state that differs between SSR and CSR
+ */
+declare function ClientOnly({ children, fallback, }: ClientOnlyProps): react_jsx_runtime.JSX.Element;
+
+interface JsonLdProps {
+    data: Record<string, any> | Record<string, any>[];
+}
+/**
+ * JsonLd Component
+ *
+ * Renders JSON-LD structured data for SEO.
+ * Use this for schema.org markup (Organization, WebSite, FAQPage, etc.)
+ *
+ * @example
+ * ```tsx
+ * <JsonLd data={{
+ *   "@context": "https://schema.org",
+ *   "@type": "Organization",
+ *   "name": "My Company"
+ * }} />
+ * ```
+ */
+declare function JsonLd({ data }: JsonLdProps): react_jsx_runtime.JSX.Element;
+
+interface LucideIconProps extends Omit<React$1.SVGProps<SVGSVGElement>, 'children'> {
+    /**
+     * Icon name (string) or icon component (LucideIcon)
+     * If string, will be resolved from lucide-react
+     * If component, will be used directly
+     */
+    icon?: LucideIcon$1 | string;
+    /**
+     * Fallback icon if name not found
+     * @default CloudLightning
+     */
+    fallback?: LucideIcon$1;
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+}
+/**
+ * LucideIcon Component
+ *
+ * Renders a Lucide icon either by name (string) or by component reference.
+ * Automatically resolves icon names from lucide-react package.
+ *
+ * Usage:
+ * ```tsx
+ * // By name (string)
+ * <LucideIcon icon="CloudLightning" className="w-4 h-4" />
+ *
+ * // By component
+ * import { CloudLightning } from 'lucide-react';
+ * <LucideIcon icon={CloudLightning} className="w-4 h-4" />
+ * ```
+ */
+declare function LucideIcon({ icon, fallback, className, ...props }: LucideIconProps): react_jsx_runtime.JSX.Element;
+
+interface SuspenseProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+declare function Suspense({ children, fallback }: SuspenseProps): react_jsx_runtime.JSX.Element;
+
+interface ErrorBoundaryProps {
+    children: ReactNode;
+    supportEmail?: string;
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+}
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): string | number | bigint | boolean | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode>> | react_jsx_runtime.JSX.Element;
+}
+
+interface ErrorLayoutProps {
+    /** Error code (e.g., "404", "500", "403") - if provided, auto-configures title/description/icon */
+    code?: string | number;
+    /** Error title (auto-generated from code if not provided) */
+    title?: string;
+    /** Error description (auto-generated from code if not provided) */
+    description?: string;
+    /** Custom action buttons */
+    actions?: React$1.ReactNode;
+    /** Show default actions (back, home) */
+    showDefaultActions?: boolean;
+    /** Custom illustration/icon (auto-generated from code if not provided) */
+    illustration?: React$1.ReactNode;
+    /** Support email for contact link */
+    supportEmail?: string;
+}
+/**
+ * ErrorLayout Component
+ */
+declare function ErrorLayout({ code, title, description, actions, showDefaultActions, illustration, supportEmail, }: ErrorLayoutProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Universal Error Configuration
+ *
+ * Provides standard error content for common HTTP status codes
+ * Use this to maintain consistency across error pages
+ *
+ * NOTE: Only returns primitives (title, description) - NO React components
+ * This ensures safe serialization during prerendering
+ */
+interface ErrorContent {
+    title: string;
+    description: string;
+}
+/**
+ * Get standardized error content based on status code
+ *
+ * @param statusCode - HTTP status code or custom error type
+ * @returns Error content configuration (title and description only)
+ *
+ * @example
+ * ```tsx
+ * const { title, description } = getErrorContent(404);
+ * <ErrorLayout title={title} description={description} code={404} />
+ * ```
+ */
+declare function getErrorContent(statusCode?: number | string): ErrorContent;
+/**
+ * Common error codes as constants
+ */
+declare const ERROR_CODES: {
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly TIMEOUT: 408;
+    readonly SERVER_ERROR: 500;
+    readonly BAD_GATEWAY: 502;
+    readonly SERVICE_UNAVAILABLE: 503;
+    readonly GATEWAY_TIMEOUT: 504;
+};
+
+interface RedirectPageProps {
+    /**
+     * Path to redirect to when user is authenticated
+     * @default '/private'
+     */
+    authenticatedPath?: string;
+    /**
+     * Path to redirect to when user is not authenticated
+     * @default '/auth'
+     */
+    unauthenticatedPath?: string;
+    /**
+     * Custom loading text
+     * @default 'Loading...'
+     */
+    loadingText?: string;
+}
+/**
+ * RedirectPage - Root page component that handles authentication redirect
+ *
+ * Redirects authenticated users to authenticatedPath, otherwise to unauthenticatedPath
+ *
+ * Usage:
+ * ```tsx
+ * // app/page.tsx
+ * import { RedirectPage } from '@djangocfg/layouts/components';
+ *
+ * export default function Page() {
+ *   return (
+ *     <RedirectPage
+ *       authenticatedPath="/private"
+ *       unauthenticatedPath="/auth"
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function RedirectPage({ authenticatedPath, unauthenticatedPath, loadingText, }: RedirectPageProps): react_jsx_runtime.JSX.Element;
+
+interface ErrorTrackingProviderProps {
+    children: ReactNode;
+    validation?: Partial<ValidationErrorConfig>;
+    cors?: Partial<CORSErrorConfig>;
+    network?: Partial<NetworkErrorConfig>;
+    centrifugo?: Partial<CentrifugoErrorConfig>;
+    onError?: (error: ErrorDetail) => boolean | void;
+}
+/**
+ * Universal Error Tracking Provider
+ *
+ * Tracks all error types with a single provider
+ */
+declare function ErrorTrackingProvider({ children, validation: userValidationConfig, cors: userCorsConfig, network: userNetworkConfig, centrifugo: userCentrifugoConfig, onError, }: ErrorTrackingProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * useErrors Hook
+ *
+ * Access errors from any component
+ *
+ * @example
+ * ```tsx
+ * function ErrorPanel() {
+ *   const { errors, validationErrors, clearErrors } = useErrors();
+ *
+ *   return (
+ *     <div>
+ *       <h3>Errors ({errors.length})</h3>
+ *       <h4>Validation: {validationErrors.length}</h4>
+ *       <button onClick={clearErrors}>Clear All</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useErrors(): ErrorTrackingContextValue;
+
+interface ErrorButtonsProps {
+    detail: ValidationErrorDetail | CORSErrorDetail | NetworkErrorDetail | CentrifugoErrorDetail;
+}
+/**
+ * Universal error buttons
+ */
+declare function ErrorButtons({ detail }: ErrorButtonsProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * ErrorToast - Universal toast for all error types
+ *
+ * Formats validation, CORS, and network errors with appropriate styling
+ */
+
+/**
+ * Create toast options for any error type
+ */
+declare function createErrorToast(detail: ValidationErrorDetail | CORSErrorDetail | NetworkErrorDetail | CentrifugoErrorDetail, config: Required<ValidationErrorConfig | CORSErrorConfig | NetworkErrorConfig | CentrifugoErrorConfig>): {
+    title: string;
+    description: React$1.ReactNode;
+    variant: "destructive";
+    duration: number;
+};
+
+/**
+ * Error Formatters
+ *
+ * Format different error types for display and copying
+ */
+
+/**
+ * Format Zod error issues for display
+ */
+declare function formatZodIssues(error: ZodError, maxIssues?: number): string;
+/**
+ * Format validation error for clipboard
+ */
+declare function formatValidationErrorForClipboard(detail: ValidationErrorDetail): string;
+/**
+ * Format CORS error for clipboard
+ */
+declare function formatCORSErrorForClipboard(detail: CORSErrorDetail): string;
+/**
+ * Format network error for clipboard
+ */
+declare function formatNetworkErrorForClipboard(detail: NetworkErrorDetail): string;
+/**
+ * Format centrifugo error for clipboard
+ */
+declare function formatCentrifugoErrorForClipboard(detail: CentrifugoErrorDetail): string;
+/**
+ * Extract domain from URL
+ */
+declare function extractDomain(url: string): string;
+/**
+ * Format error title based on type
+ */
+declare function formatErrorTitle(detail: ValidationErrorDetail | CORSErrorDetail | NetworkErrorDetail | CentrifugoErrorDetail): string;
+
+interface CurlOptions {
+    method: string;
+    path: string;
+    token?: string;
+    body?: any;
+    headers?: Record<string, string>;
+    baseUrl?: string;
+    queryParams?: Record<string, string>;
+}
+/**
+ * Get authentication token from localStorage
+ */
+declare function getAuthToken(): string | null;
+/**
+ * Generate cURL command from request details
+ */
+declare function generateCurl(options: CurlOptions): string;
+/**
+ * Generate cURL from validation error details
+ * Auto-fetches token from localStorage
+ */
+declare function generateCurlFromError(detail: {
+    method: string;
+    path: string;
+    response?: any;
+}): string;
+
+/**
+ * Frontend configuration from environment variables
+ */
+declare const config: {
+    /**
+     * Development mode flag
+     * In development mode, any OTP code is accepted for authentication
+     */
+    readonly isDevelopment: boolean;
+};
+
+declare const logger: consola.ConsolaInstance;
+/**
+ * Auth-specific logger
+ */
+declare const authLogger: consola.ConsolaInstance;
+/**
+ * Chat-specific logger
+ */
+declare const chatLogger: consola.ConsolaInstance;
+/**
+ * Support-specific logger
+ */
+declare const supportLogger: consola.ConsolaInstance;
+/**
+ * Payments-specific logger
+ */
+declare const paymentsLogger: consola.ConsolaInstance;
+/**
+ * Profile-specific logger
+ */
+declare const profileLogger: consola.ConsolaInstance;
+/**
+ * Dashboard-specific logger
+ */
+declare const dashboardLogger: consola.ConsolaInstance;
+
+/**
+ * Legal page types
+ */
+interface LegalPageSection {
+    title: string;
+    content: string | string[];
+}
+interface LegalPageConfig {
+    title: string;
+    lastUpdated?: string | Date;
+    sections: LegalPageSection[];
+}
+
+interface LegalPageProps {
+    config: LegalPageConfig;
+    className?: string;
+}
+/**
+ * LegalPage Component
+ */
+declare function LegalPage({ config, className }: LegalPageProps): react_jsx_runtime.JSX.Element;
+
+interface LegalPageComponentProps {
+    config?: LegalPageConfig;
+}
+/**
+ * Privacy Policy Page
+ */
+declare function PrivacyPage({ config }?: LegalPageComponentProps): react_jsx_runtime.JSX.Element;
+/**
+ * Terms of Service Page
+ */
+declare function TermsPage({ config }?: LegalPageComponentProps): react_jsx_runtime.JSX.Element;
+/**
+ * Cookie Policy Page
+ */
+declare function CookiesPage({ config }?: LegalPageComponentProps): react_jsx_runtime.JSX.Element;
+/**
+ * Security Policy Page
+ */
+declare function SecurityPage({ config }?: LegalPageComponentProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Default legal page configurations
+ *
+ * Pre-configured content for common legal pages
+ * Can be customized or extended as needed
+ */
+
+declare const privacyConfig: LegalPageConfig;
+declare const termsConfig: LegalPageConfig;
+declare const cookiesConfig: LegalPageConfig;
+declare const securityConfig: LegalPageConfig;
+
+export { A2HSHint, type AIChatApiResponse, type AIChatContextActions, type AIChatContextState, type AIChatContextValue, type AIChatMessage, AIChatProvider, type AIChatProviderProps, type AIChatSource, AIChatWidget, type AIChatWidgetProps, AIMessageInput, type AIMessageInputProps, type AIMessageRole, AUTH_EVENTS, AdminLayout, type AdminLayoutProps, Analytics, AnalyticsCategory, type AnalyticsCategoryType, type AnalyticsConfig, AnalyticsEvent, type AnalyticsEventType, AnalyticsProvider, type AndroidInstallButtonProps, AppLayout, type AppLayoutProps, AskAIButton, type AskAIButtonProps, AuthDialog, type AuthEventType, type AuthFailurePayload, AuthFormProvider, AuthHelp, AuthLayout, type AuthSuccessPayload, BaseApp, type BaseAppProps, type BaseLayoutProps, type BeforeInstallPromptEvent, type BreadcrumbItem, type CORSErrorConfig, type CORSErrorDetail, type CentrifugoConfig, type CentrifugoErrorConfig, type CentrifugoErrorDetail, type ChatLayoutConfig, ChatPanel, type ChatWidgetConfig, ClientOnly, type ClientOnlyProps, CookiesPage, type CurlOptions, DEFAULT_VAPID_PUBLIC_KEY, DIALOG_EVENTS, DesktopGuide, DjangoCFGLogo, DjangoPushProvider, ERROR_CODES, ErrorBoundary, type ErrorBoundaryConfig, ErrorButtons, type ErrorContent, type ErrorDetail, ErrorLayout, type ErrorLayoutProps, type ErrorTrackingConfig, type ErrorTrackingContextValue, ErrorTrackingProvider, FooterBottom, type FooterConfig, type FooterLink$1 as FooterLink, type FooterMenuSection$1 as FooterMenuSection, FooterMenuSections, FooterProjectInfo, type FooterSocialLinks$1 as FooterSocialLinks, FooterSocialLinksComponent, type HeaderConfig, IOSGuide, type IOSGuideModalProps, type IOSGuideState, IdentifierForm, type InstallContextType, type InstallManagerProps, type InstallOutcome, type InstallPromptState, type InstallStep, JsonLd, type LayoutMode, LegalPage, type LegalPageComponentProps, type LegalPageConfig, type LegalPageProps, type LegalPageSection, LucideIcon, type LucideIconProps, type McpChatConfig, type McpChatContextType, type McpChatEventDetail, MessageBubble, type MessageBubbleProps, type NavigationItem, type NavigationSection, type NetworkErrorConfig, type NetworkErrorDetail, OAuthCallback, type OAuthCallbackProps, OAuthProviders, OTPForm, type OpenAuthDialogPayload, type PlatformInfo, PrivacyPage, PrivateLayout, type PrivateLayoutProps, ProfileLayout, PublicFooter, type PublicFooterProps, PublicLayout, type PublicLayoutProps, type PushMessage, type PushNotificationOptions, type PushNotificationState, type PushNotificationsConfig, PushPrompt, DjangoPushProvider as PushProvider, type PwaInstallConfig, PwaProvider, RedirectPage, type RedirectPageProps, type SWRConfigOptions, SecurityPage, type SidebarConfig, type SidebarItem, type StoredError, Suspense, TermsPage, type ThemeConfig, type UseAIChatOptions, type UseAIChatReturn, type UseChatLayoutReturn, type UseIsPWAOptions, type UseMcpChatReturn, UserMenu, type UserMenuConfig, type UserMenuGroup, type UserMenuItem, type UserMenuProps, type ValidationErrorConfig, type ValidationErrorDetail, VapidKeyError, type VapidKeyErrorCode, authLogger, chatLogger, clearAllPWAInstallData, clearAllPushData, clearIsPWACache, config, cookiesConfig, createErrorToast, dashboardLogger, extractDomain, formatCORSErrorForClipboard, formatCentrifugoErrorForClipboard, formatErrorTitle, formatNetworkErrorForClipboard, formatValidationErrorForClipboard, formatZodIssues, generateBreadcrumbsFromPath, generateCurl, generateCurlFromError, getAuthToken, getDisplayMode, getErrorContent, getVapidKeyInfo, hasValidManifest, isMobileDevice, isStandalone, isStandaloneReliable, isValidVapidKey, logger, onDisplayModeChange, paymentsLogger, privacyConfig, profileLogger, safeUrlBase64ToUint8Array, securityConfig, supportLogger, termsConfig, urlBase64ToUint8Array, useAIChat, useAIChatContext, useAIChatContextOptional, useAnalytics, useAuthDialog, useAuthFormContext, useChatLayout, useDjangoPush, useDjangoPushContext, useErrors, useInstall, useIsPWA, useMcpChat, useDjangoPushContext as usePush, usePushNotifications };