@robosystems/core 0.3.0

package/contexts/service-offerings-context.js

@@ -0,0 +1,98 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState } from 'react';
+import { SDK } from '..';
+const ServiceOfferingsContext = createContext({
+    offerings: null,
+    isLoading: true,
+    error: null,
+    refresh: async () => { },
+});
+export function ServiceOfferingsProvider({ children, }) {
+    const [offerings, setOfferings] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const fetchOfferings = async () => {
+        var _a, _b, _c;
+        try {
+            setIsLoading(true);
+            setError(null);
+            const response = await SDK.getServiceOfferings();
+            if (response.data) {
+                // Transform the API response to match our expected structure
+                const apiData = response.data;
+                // Transform repository_subscriptions.repositories array into repositoryPlans object
+                const repositoryPlans = {};
+                if ((_a = apiData.repository_subscriptions) === null || _a === void 0 ? void 0 : _a.repositories) {
+                    apiData.repository_subscriptions.repositories.forEach((repo) => {
+                        repositoryPlans[repo.type] = {
+                            name: repo.name,
+                            description: repo.description,
+                            enabled: repo.enabled,
+                            comingSoon: repo.coming_soon,
+                            plans: repo.plans.map((plan) => ({
+                                plan: plan.plan,
+                                name: plan.name,
+                                monthlyPrice: plan.monthly_price,
+                                monthlyCredits: plan.monthly_credits,
+                                features: plan.features,
+                            })),
+                        };
+                    });
+                }
+                // Transform graph tiers array into graphPlans object
+                const graphPlans = {};
+                if ((_b = apiData.graph_subscriptions) === null || _b === void 0 ? void 0 : _b.tiers) {
+                    apiData.graph_subscriptions.tiers.forEach((tier) => {
+                        var _a, _b;
+                        // Skip trial tier for selection
+                        if (tier.name === 'trial')
+                            return;
+                        graphPlans[tier.name] = {
+                            name: tier.name,
+                            displayName: tier.display_name,
+                            monthlyPrice: tier.monthly_price,
+                            monthlyCredits: tier.monthly_credits,
+                            features: tier.features || [],
+                            creditMultiplier: ((_b = (_a = apiData.graph_subscriptions) === null || _a === void 0 ? void 0 : _a.tier_multipliers) === null || _b === void 0 ? void 0 : _b[tier.name]) || 1,
+                            instanceStorageLimitGb: tier.instance_storage_limit_gb,
+                        };
+                    });
+                }
+                const offerings = {
+                    billingEnabled: (_c = apiData.billing_enabled) !== null && _c !== void 0 ? _c : true,
+                    repositoryPlans,
+                    graphPlans,
+                    features: apiData.features,
+                };
+                setOfferings(offerings);
+            }
+            else {
+                throw new Error('No data received from service offerings API');
+            }
+        }
+        catch (err) {
+            console.error('Failed to fetch service offerings:', err);
+            setError('Failed to load service offerings');
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    useEffect(() => {
+        fetchOfferings();
+    }, []);
+    return (_jsx(ServiceOfferingsContext.Provider, { value: {
+            offerings,
+            isLoading,
+            error,
+            refresh: fetchOfferings,
+        }, children: children }));
+}
+export function useServiceOfferings() {
+    const context = useContext(ServiceOfferingsContext);
+    if (!context) {
+        throw new Error('useServiceOfferings must be used within ServiceOfferingsProvider');
+    }
+    return context;
+}

package/contexts/sidebar-context.d.ts

@@ -0,0 +1,18 @@
+import type { PropsWithChildren } from 'react';
+interface SidebarContextProps {
+    desktop: {
+        isCollapsed: boolean;
+        setCollapsed(value: boolean): void;
+        toggle(): void;
+    };
+    mobile: {
+        isOpen: boolean;
+        close(): void;
+        toggle(): void;
+    };
+}
+export declare function SidebarProvider({ initialCollapsed, children, }: PropsWithChildren<{
+    initialCollapsed: boolean;
+}>): import("react").JSX.Element;
+export declare function useSidebarContext(): SidebarContextProps;
+export {};

package/contexts/sidebar-context.js

@@ -0,0 +1,44 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState } from 'react';
+const SidebarContext = createContext(null);
+export function SidebarProvider({ initialCollapsed, children, }) {
+    const [isOpenMobile, setIsOpenMobile] = useState(false);
+    const [isCollapsed, setCollapsed] = useState(initialCollapsed);
+    function handleSetCollapsed(value) {
+        setCollapsed(value);
+        setCookie(value);
+    }
+    function setCookie(value) {
+        fetch('/api/session/sidebar', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                isCollapsed: value,
+            }),
+        }).catch((error) => {
+            console.error('Failed to save sidebar state:', error);
+        });
+    }
+    return (_jsx(SidebarContext.Provider, { value: {
+            desktop: {
+                isCollapsed,
+                setCollapsed: handleSetCollapsed,
+                toggle: () => handleSetCollapsed(!isCollapsed),
+            },
+            mobile: {
+                isOpen: isOpenMobile,
+                close: () => setIsOpenMobile(false),
+                toggle: () => setIsOpenMobile((state) => !state),
+            },
+        }, children: children }));
+}
+export function useSidebarContext() {
+    const context = useContext(SidebarContext);
+    if (!context) {
+        throw new Error('useSidebarContext must be used within the SidebarContext provider!');
+    }
+    return context;
+}

package/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export { useApiError } from './use-api-error';
+export { useMediaQuery } from './use-media-query';
+export { useStreamingQuery } from './use-streaming-query';
+export { useToast, type ToastMessage } from './use-toast';
+export { useUser } from './use-user';
+export { useOrgLimits, useUserLimits } from './use-user-limits';

package/hooks/index.js

@@ -0,0 +1,6 @@
+export { useApiError } from './use-api-error';
+export { useMediaQuery } from './use-media-query';
+export { useStreamingQuery } from './use-streaming-query';
+export { useToast } from './use-toast';
+export { useUser } from './use-user';
+export { useOrgLimits, useUserLimits } from './use-user-limits';

package/hooks/use-api-error.d.ts

@@ -0,0 +1,3 @@
+export declare function useApiError(): {
+    handleApiError: (error: any, defaultMessage: string) => string;
+};

package/hooks/use-api-error.js

@@ -0,0 +1,24 @@
+import { useCallback } from 'react';
+import { useToast } from './use-toast';
+export function useApiError() {
+    const { showError } = useToast();
+    const handleApiError = useCallback((error, defaultMessage) => {
+        var _a, _b, _c, _d;
+        let errorMessage = defaultMessage;
+        if (error instanceof Error) {
+            errorMessage = error.message;
+        }
+        else if ((_b = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.detail) {
+            errorMessage = error.response.data.detail;
+        }
+        else if ((_d = (_c = error === null || error === void 0 ? void 0 : error.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.message) {
+            errorMessage = error.response.data.message;
+        }
+        else if (error === null || error === void 0 ? void 0 : error.message) {
+            errorMessage = error.message;
+        }
+        showError(errorMessage);
+        return errorMessage;
+    }, [showError]);
+    return { handleApiError };
+}

package/hooks/use-media-query.d.ts

@@ -0,0 +1 @@
+export declare function useMediaQuery(query: string): boolean;

package/hooks/use-media-query.js

@@ -0,0 +1,21 @@
+'use client';
+import { useEffect, useState } from 'react';
+export function useMediaQuery(query) {
+    const [matches, setMatches] = useState(getMatches(query));
+    function getMatches(query) {
+        if (typeof window === 'undefined')
+            return false;
+        return window.matchMedia(query).matches;
+    }
+    function handleChange() {
+        setMatches(getMatches(query));
+    }
+    useEffect(() => {
+        const matchMedia = window.matchMedia(query);
+        handleChange();
+        matchMedia.addEventListener('change', handleChange);
+        return () => matchMedia.removeEventListener('change', handleChange);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [query]);
+    return matches;
+}

package/hooks/use-streaming-query.d.ts

@@ -0,0 +1,22 @@
+export interface StreamingQueryState {
+    isStreaming: boolean;
+    results: any[];
+    error: string | null;
+    progress: number | null;
+    totalRows: number | null;
+    currentRow: number | null;
+    status: 'idle' | 'connecting' | 'streaming' | 'completed' | 'error' | 'cancelled';
+    creditsUsed: number | null;
+    cached: boolean;
+    duration: number | null;
+}
+export interface UseStreamingQueryResult extends StreamingQueryState {
+    executeQuery: (graphId: string, query: string, parameters?: Record<string, any>) => Promise<void>;
+    cancelQuery: () => void;
+    reset: () => void;
+}
+/**
+ * Hook for streaming query results using SDK extensions when available
+ * Falls back to manual SSE implementation for older SDK versions
+ */
+export declare function useStreamingQuery(): UseStreamingQueryResult;

package/hooks/use-streaming-query.js

@@ -0,0 +1,142 @@
+'use client';
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { useCallback, useRef, useState } from 'react';
+// Import SDK extensions - check at runtime
+const getSDKExtensions = async () => {
+    try {
+        return await import('@robosystems/client/clients');
+    }
+    catch (error) {
+        console.error('SDK extensions not available:', error);
+        return null;
+    }
+};
+/**
+ * Hook for streaming query results using SDK extensions when available
+ * Falls back to manual SSE implementation for older SDK versions
+ */
+export function useStreamingQuery() {
+    const [state, setState] = useState({
+        isStreaming: false,
+        results: [],
+        error: null,
+        progress: null,
+        totalRows: null,
+        currentRow: null,
+        status: 'idle',
+        creditsUsed: null,
+        cached: false,
+        duration: null,
+    });
+    const eventSourceRef = useRef(null);
+    const startTimeRef = useRef(null);
+    const queryClientRef = useRef(null);
+    const reset = useCallback(() => {
+        var _a;
+        if (eventSourceRef.current) {
+            eventSourceRef.current.close();
+            eventSourceRef.current = null;
+        }
+        if ((_a = queryClientRef.current) === null || _a === void 0 ? void 0 : _a.close) {
+            queryClientRef.current.close();
+            queryClientRef.current = null;
+        }
+        setState({
+            isStreaming: false,
+            results: [],
+            error: null,
+            progress: null,
+            totalRows: null,
+            currentRow: null,
+            status: 'idle',
+            creditsUsed: null,
+            cached: false,
+            duration: null,
+        });
+    }, []);
+    const cancelQuery = useCallback(() => {
+        var _a;
+        if (eventSourceRef.current) {
+            eventSourceRef.current.close();
+            eventSourceRef.current = null;
+        }
+        if ((_a = queryClientRef.current) === null || _a === void 0 ? void 0 : _a.close) {
+            queryClientRef.current.close();
+            queryClientRef.current = null;
+        }
+        setState((prev) => (Object.assign(Object.assign({}, prev), { isStreaming: false, status: 'cancelled', error: 'Query was cancelled' })));
+    }, []);
+    const executeQuery = useCallback(async (graphId, query, parameters) => {
+        // Get SDK extensions at runtime
+        const sdkExtensions = await getSDKExtensions();
+        // Require SDK extensions - fail fast if not available
+        if (!(sdkExtensions === null || sdkExtensions === void 0 ? void 0 : sdkExtensions.streamQuery)) {
+            throw new Error('SDK extensions not available. Please install @robosystems/client with extensions support.');
+        }
+        return executeQueryWithExtensions(graphId, query, sdkExtensions, parameters);
+    }, []);
+    // Helper function to execute query with SDK extensions
+    const executeQueryWithExtensions = async (graphId, query, sdkExtensions, parameters) => {
+        var _a, e_1, _b, _c;
+        try {
+            // Reset state for new query
+            setState({
+                isStreaming: true,
+                results: [],
+                error: null,
+                progress: 0,
+                totalRows: null,
+                currentRow: 0,
+                status: 'connecting',
+                creditsUsed: null,
+                cached: false,
+                duration: null,
+            });
+            startTimeRef.current = Date.now();
+            // Use the centralized streamQuery function with proper authentication
+            const iterator = sdkExtensions.streamQuery(graphId, query, parameters, 100);
+            setState((prev) => (Object.assign(Object.assign({}, prev), { status: 'streaming' })));
+            let rowCount = 0;
+            const allResults = [];
+            try {
+                for (var _d = true, iterator_1 = __asyncValues(iterator), iterator_1_1; iterator_1_1 = await iterator_1.next(), _a = iterator_1_1.done, !_a; _d = true) {
+                    _c = iterator_1_1.value;
+                    _d = false;
+                    const batch = _c;
+                    // Handle both single rows and batches
+                    const rows = Array.isArray(batch) ? batch : [batch];
+                    for (const row of rows) {
+                        rowCount++;
+                        allResults.push(row);
+                    }
+                    // Update state with progress
+                    setState((prev) => (Object.assign(Object.assign({}, prev), { results: [...allResults], currentRow: rowCount, progress: prev.totalRows
+                            ? Math.round((rowCount / prev.totalRows) * 100)
+                            : null })));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = iterator_1.return)) await _b.call(iterator_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            const duration = Date.now() - startTimeRef.current;
+            setState((prev) => (Object.assign(Object.assign({}, prev), { isStreaming: false, status: 'completed', results: allResults, totalRows: rowCount, currentRow: rowCount, progress: 100, duration })));
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Query execution failed';
+            setState((prev) => (Object.assign(Object.assign({}, prev), { isStreaming: false, status: 'error', error: errorMessage })));
+        }
+    };
+    return Object.assign(Object.assign({}, state), { executeQuery,
+        cancelQuery,
+        reset });
+}

package/hooks/use-toast.d.ts

@@ -0,0 +1,37 @@
+export interface ToastMessage {
+    id: string;
+    type: 'success' | 'error' | 'warning' | 'info';
+    message: string;
+    duration?: number;
+}
+/**
+ * A reusable toast notification hook built on Flowbite React components.
+ *
+ * Provides toast notifications with auto-dismiss functionality and consistent styling
+ * across the RoboSystems ecosystem.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { showSuccess, showError, ToastContainer } = useToast()
+ *
+ *   const handleSuccess = () => {
+ *     showSuccess('Operation completed successfully!')
+ *   }
+ *
+ *   return (
+ *     <>
+ *       <ToastContainer />
+ *       <button onClick={handleSuccess}>Show Success Toast</button>
+ *     </>
+ *   )
+ * }
+ * ```
+ */
+export declare function useToast(): {
+    showSuccess: (message: string, duration?: number) => void;
+    showError: (message: string, duration?: number) => void;
+    showWarning: (message: string, duration?: number) => void;
+    showInfo: (message: string, duration?: number) => void;
+    ToastContainer: () => import("react").JSX.Element;
+};

package/hooks/use-toast.js

@@ -0,0 +1,117 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Toast, ToastToggle } from 'flowbite-react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { HiCheckCircle, HiExclamation, HiInformationCircle, } from 'react-icons/hi';
+/**
+ * A reusable toast notification hook built on Flowbite React components.
+ *
+ * Provides toast notifications with auto-dismiss functionality and consistent styling
+ * across the RoboSystems ecosystem.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { showSuccess, showError, ToastContainer } = useToast()
+ *
+ *   const handleSuccess = () => {
+ *     showSuccess('Operation completed successfully!')
+ *   }
+ *
+ *   return (
+ *     <>
+ *       <ToastContainer />
+ *       <button onClick={handleSuccess}>Show Success Toast</button>
+ *     </>
+ *   )
+ * }
+ * ```
+ */
+export function useToast() {
+    const [toasts, setToasts] = useState([]);
+    const timeoutRefs = useRef({});
+    const addToast = useCallback((toast) => {
+        const id = Math.random().toString(36).substring(2, 11);
+        const newToast = Object.assign({ id, duration: 5000 }, toast);
+        setToasts((prev) => [...prev, newToast]);
+        if (newToast.duration && newToast.duration > 0) {
+            const timeoutId = setTimeout(() => {
+                setToasts((prev) => prev.filter((t) => t.id !== id));
+                delete timeoutRefs.current[id];
+            }, newToast.duration);
+            timeoutRefs.current[id] = timeoutId;
+        }
+    }, []);
+    const removeToast = useCallback((id) => {
+        if (timeoutRefs.current[id]) {
+            clearTimeout(timeoutRefs.current[id]);
+            delete timeoutRefs.current[id];
+        }
+        setToasts((prev) => prev.filter((t) => t.id !== id));
+    }, []);
+    const showSuccess = useCallback((message, duration) => {
+        addToast({ type: 'success', message, duration });
+    }, [addToast]);
+    const showError = useCallback((message, duration) => {
+        addToast({ type: 'error', message, duration });
+    }, [addToast]);
+    const showWarning = useCallback((message, duration) => {
+        addToast({ type: 'warning', message, duration });
+    }, [addToast]);
+    const showInfo = useCallback((message, duration) => {
+        addToast({ type: 'info', message, duration });
+    }, [addToast]);
+    // Cleanup all timeouts on unmount
+    useEffect(() => {
+        const timeouts = timeoutRefs.current;
+        return () => {
+            Object.values(timeouts).forEach(clearTimeout);
+        };
+    }, []);
+    const ToastContainer = useCallback(() => (_jsx("div", { className: "fixed top-4 right-4 z-50 flex flex-col gap-2", children: toasts.map((toast) => {
+            const getIcon = () => {
+                switch (toast.type) {
+                    case 'success':
+                        return HiCheckCircle;
+                    case 'error':
+                        return HiExclamation;
+                    case 'warning':
+                        return HiExclamation;
+                    case 'info':
+                        return HiInformationCircle;
+                    default:
+                        return HiInformationCircle;
+                }
+            };
+            const getColor = () => {
+                switch (toast.type) {
+                    case 'success':
+                        return 'success';
+                    case 'error':
+                        return 'failure';
+                    case 'warning':
+                        return 'warning';
+                    case 'info':
+                        return 'info';
+                    default:
+                        return 'info';
+                }
+            };
+            const Icon = getIcon();
+            const color = getColor();
+            return (_jsxs(Toast, { className: "min-w-80", color: color, children: [_jsx("div", { className: `inline-flex h-8 w-8 shrink-0 items-center justify-center rounded-lg ${toast.type === 'success'
+                            ? 'bg-green-100 text-green-500 dark:bg-green-800 dark:text-green-200'
+                            : toast.type === 'error'
+                                ? 'bg-red-100 text-red-500 dark:bg-red-800 dark:text-red-200'
+                                : toast.type === 'warning'
+                                    ? 'bg-orange-100 text-orange-500 dark:bg-orange-700 dark:text-orange-200'
+                                    : 'bg-primary-100 text-primary-500 dark:bg-primary-800 dark:text-primary-200'}`, children: _jsx(Icon, { className: "h-5 w-5" }) }), _jsx("div", { className: "ml-3 text-sm font-normal", children: toast.message }), _jsx(ToastToggle, { onClick: () => removeToast(toast.id) })] }, toast.id));
+        }) })), [toasts, removeToast]);
+    return {
+        showSuccess,
+        showError,
+        showWarning,
+        showInfo,
+        ToastContainer,
+    };
+}

package/hooks/use-user-limits.d.ts

@@ -0,0 +1,12 @@
+import type { OrgLimitsResponse } from '@robosystems/client';
+interface UseOrgLimitsReturn {
+    limits: OrgLimitsResponse | null;
+    isLoading: boolean;
+    error: string | null;
+    canCreateGraph: boolean;
+    remainingGraphs: number;
+    refetch: () => Promise<void>;
+}
+export declare function useOrgLimits(): UseOrgLimitsReturn;
+export declare const useUserLimits: typeof useOrgLimits;
+export {};

package/hooks/use-user-limits.js

@@ -0,0 +1,73 @@
+'use client';
+import * as SDK from '@robosystems/client';
+import { useCallback, useEffect, useState } from 'react';
+import { useOrg } from '../contexts/org-context';
+export function useOrgLimits() {
+    var _a;
+    const [limits, setLimits] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [currentGraphCount, setCurrentGraphCount] = useState(0);
+    const { currentOrg } = useOrg();
+    const fetchLimits = useCallback(async () => {
+        if (!(currentOrg === null || currentOrg === void 0 ? void 0 : currentOrg.id)) {
+            setIsLoading(false);
+            return;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            // Fetch org limits and graphs in parallel
+            const [limitsResponse, graphsResponse] = await Promise.allSettled([
+                SDK.getOrgLimits({ path: { org_id: currentOrg.id } }),
+                SDK.getGraphs(),
+            ]);
+            // Process org limits
+            if (limitsResponse.status === 'fulfilled' && limitsResponse.value.data) {
+                setLimits(limitsResponse.value.data);
+            }
+            else {
+                setLimits(null);
+            }
+            // Process graphs to count user graphs (not repositories)
+            if (graphsResponse.status === 'fulfilled' && graphsResponse.value.data) {
+                const graphsData = graphsResponse.value.data;
+                const graphs = graphsData.graphs || [];
+                // Only count user graphs, not shared repositories
+                const userGraphs = graphs.filter((g) => !g.isRepository);
+                setCurrentGraphCount(userGraphs.length);
+            }
+        }
+        catch (err) {
+            // Use structured logging instead of console.error for production
+            if (process.env.NODE_ENV === 'development') {
+                console.error('Failed to fetch org limits:', err);
+            }
+            setError('Failed to fetch org limits');
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [currentOrg === null || currentOrg === void 0 ? void 0 : currentOrg.id]);
+    // Fetch limits on mount
+    useEffect(() => {
+        fetchLimits();
+    }, [fetchLimits]);
+    // Calculate derived values
+    // Use the can_create_graph field directly from the API response
+    // The backend calculates this based on org limits
+    const canCreateGraph = (_a = limits === null || limits === void 0 ? void 0 : limits.can_create_graph) !== null && _a !== void 0 ? _a : true;
+    const remainingGraphs = limits
+        ? Math.max(0, limits.max_graphs - currentGraphCount)
+        : 999; // Show high number when limits unavailable
+    return {
+        limits,
+        isLoading,
+        error,
+        canCreateGraph,
+        remainingGraphs,
+        refetch: fetchLimits,
+    };
+}
+// Backward compatibility export
+export const useUserLimits = useOrgLimits;

package/hooks/use-user.d.ts

@@ -0,0 +1,11 @@
+export declare function useUser(): {
+    user: {
+        id: string;
+        name: string;
+        email: string;
+        emailVerified: boolean;
+    };
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    refreshUser: () => Promise<import("..").AuthUser | null>;
+};