@strato-admin/core 0.1.1 → 0.3.0

package/dist/index.d.ts

@@ -1,3 +1,4 @@
-export * from '@strato-admin/ra-core';
 export * from './resource';
-export { ResourceContext } from './resource';
+export * from './routing';
+export * from './settings/SettingsContext';
+export * from './settings/useSettingValue';

package/dist/index.js

@@ -1,4 +1,4 @@
-export * from '@strato-admin/ra-core';
 export * from './resource';
-// Resolve ambiguity between ra-core and strato-core resource exports.
-export { ResourceContext } from './resource';
+export * from './routing';
+export * from './settings/SettingsContext';
+export * from './settings/useSettingValue';

package/dist/ra-core/src/auth/AuthContext.d.ts

@@ -0,0 +1,2 @@
+import { AuthProvider } from '../types';
+export declare const AuthContext: import("react").Context<AuthProvider | undefined>;

package/dist/ra-core/src/auth/AuthContext.js

@@ -0,0 +1,3 @@
+import { createContext } from 'react';
+export const AuthContext = createContext(undefined);
+AuthContext.displayName = 'AuthContext';

package/dist/ra-core/src/auth/Authenticated.d.ts

@@ -0,0 +1,40 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+/**
+ * Restrict access to children to authenticated users.
+ * Redirects anonymous users to the login page.
+ *
+ * Use it to decorate your custom page components to require
+ * authentication.
+ *
+ * @see useAuthState
+ *
+ * @example
+ * import { Admin, CustomRoutes, Authenticated } from 'react-admin';
+ *
+ * const customRoutes = [
+ *     <Route
+ *         path="/foo"
+ *         element={
+ *             <Authenticated authParams={{ foo: 'bar' }}>
+ *                 <Foo />
+ *             </Authenticated>
+ *         }
+ *     />
+ * ];
+ * const App = () => (
+ *     <Admin>
+ *         <CustomRoutes>{customRoutes}</CustomRoutes>
+ *     </Admin>
+ * );
+ */
+export declare const Authenticated: (props: AuthenticatedProps) => string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null;
+export interface AuthenticatedProps {
+    children: ReactNode;
+    authParams?: object;
+    loading?: ReactNode;
+    /**
+     * @deprecated Authenticated now never renders children when not authenticated.
+     */
+    requireAuth?: boolean;
+}

package/dist/ra-core/src/auth/Authenticated.js

@@ -0,0 +1,39 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useAuthenticated } from './useAuthenticated';
+/**
+ * Restrict access to children to authenticated users.
+ * Redirects anonymous users to the login page.
+ *
+ * Use it to decorate your custom page components to require
+ * authentication.
+ *
+ * @see useAuthState
+ *
+ * @example
+ * import { Admin, CustomRoutes, Authenticated } from 'react-admin';
+ *
+ * const customRoutes = [
+ *     <Route
+ *         path="/foo"
+ *         element={
+ *             <Authenticated authParams={{ foo: 'bar' }}>
+ *                 <Foo />
+ *             </Authenticated>
+ *         }
+ *     />
+ * ];
+ * const App = () => (
+ *     <Admin>
+ *         <CustomRoutes>{customRoutes}</CustomRoutes>
+ *     </Admin>
+ * );
+ */
+export const Authenticated = (props) => {
+    const { authParams, loading = null, children } = props;
+    // this hook will redirect to login if the user is not authenticated
+    const { isPending, isError } = useAuthenticated({ params: authParams });
+    if (isPending || isError) {
+        return loading;
+    }
+    return _jsx(_Fragment, { children: children });
+};

package/dist/ra-core/src/auth/CanAccess.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { UseCanAccessOptions } from './useCanAccess';
+import { RaRecord } from '../types';
+/**
+ * A component that only displays its children after checking whether users are authorized to access the provided resource and action.
+ * @param options
+ * @param options.action The action to check. One of 'list', 'create', 'edit', 'show', 'delete', or a custom action.
+ * @param options.resource The resource to check. e.g. 'posts', 'comments', 'users'
+ * @param options.children The component to render if users are authorized.
+ * @param options.loading An optional element to render while the authorization is being checked. Defaults to null.
+ * @param options.accessDenied An optional element to render if users are denied access. Defaults to null.
+ * @param options.error An optional element to render if an error occur while checking users access rights. Redirect users to `/authentication-error` by default.
+ */
+export declare const CanAccess: <RecordType extends RaRecord | Omit<RaRecord, "id"> = RaRecord, ErrorType extends Error = Error>({ children, loading, accessDenied, error: errorElement, ...props }: CanAccessProps<RecordType, ErrorType>) => React.ReactNode;
+export interface CanAccessProps<RecordType extends RaRecord | Omit<RaRecord, 'id'> = RaRecord, ErrorType extends Error = Error> extends UseCanAccessOptions<RecordType, ErrorType> {
+    children: React.ReactNode;
+    loading?: React.ReactNode;
+    accessDenied?: React.ReactNode;
+    error?: React.ReactNode;
+}

package/dist/ra-core/src/auth/CanAccess.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCanAccess } from './useCanAccess';
+import { useBasename, Navigate } from '../routing';
+/**
+ * A component that only displays its children after checking whether users are authorized to access the provided resource and action.
+ * @param options
+ * @param options.action The action to check. One of 'list', 'create', 'edit', 'show', 'delete', or a custom action.
+ * @param options.resource The resource to check. e.g. 'posts', 'comments', 'users'
+ * @param options.children The component to render if users are authorized.
+ * @param options.loading An optional element to render while the authorization is being checked. Defaults to null.
+ * @param options.accessDenied An optional element to render if users are denied access. Defaults to null.
+ * @param options.error An optional element to render if an error occur while checking users access rights. Redirect users to `/authentication-error` by default.
+ */
+export const CanAccess = ({ children, loading = null, accessDenied = null, error: errorElement = DEFAULT_ERROR, ...props }) => {
+    const { canAccess, error, isPending } = useCanAccess(props);
+    if (isPending) {
+        return loading;
+    }
+    if (error) {
+        return errorElement;
+    }
+    if (canAccess === false) {
+        return accessDenied;
+    }
+    return children;
+};
+const CanAccessDefaultError = () => {
+    const basename = useBasename();
+    return _jsx(Navigate, { to: `${basename}/authentication-error` });
+};
+const DEFAULT_ERROR = _jsx(CanAccessDefaultError, {});

package/dist/ra-core/src/auth/LogoutOnMount.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Log the user out and redirect them to login.
+ *
+ * To be used as a catch-all route for anonymous users in a secure app.
+ *
+ * @see CoreAdminRoutes
+ */
+export declare const LogoutOnMount: () => null;

package/dist/ra-core/src/auth/LogoutOnMount.js

@@ -0,0 +1,16 @@
+import { useEffect } from 'react';
+import useLogout from './useLogout';
+/**
+ * Log the user out and redirect them to login.
+ *
+ * To be used as a catch-all route for anonymous users in a secure app.
+ *
+ * @see CoreAdminRoutes
+ */
+export const LogoutOnMount = () => {
+    const logout = useLogout();
+    useEffect(() => {
+        logout();
+    }, [logout]);
+    return null;
+};

package/dist/ra-core/src/auth/WithPermissions.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { ComponentType } from 'react';
+import type { RouterLocation } from '../routing';
+export interface WithPermissionsChildrenParams {
+    permissions: any;
+}
+type WithPermissionsChildren = (params: WithPermissionsChildrenParams) => React.ReactNode;
+export interface WithPermissionsProps {
+    authParams?: object;
+    children?: WithPermissionsChildren;
+    component?: ComponentType<any>;
+    loading?: ComponentType<any>;
+    location?: RouterLocation;
+    render?: WithPermissionsChildren;
+    staticContext?: object;
+    [key: string]: any;
+}
+declare const _default: ComponentType<WithPermissionsProps>;
+export default _default;

package/dist/ra-core/src/auth/WithPermissions.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Children, createElement } from 'react';
+import warning from '../util/warning';
+import { useAuthenticated } from './useAuthenticated';
+import usePermissions from './usePermissions';
+const isEmptyChildren = children => Children.count(children) === 0;
+/**
+ * After checking that the user is authenticated,
+ * retrieves the user's permissions for a specific context.
+ *
+ * Useful for Route components ; used internally by Resource.
+ * Use it to decorate your custom page components to require
+ * a custom role. It will pass the permissions as a prop to your
+ * component.
+ *
+ * You can set additional `authParams` at will if your authProvider
+ * requires it.
+ *
+ * @example
+ *     import { Admin, CustomRoutes, WithPermissions } from 'react-admin';
+ *
+ *     const Foo = ({ permissions }) => (
+ *         {permissions === 'admin' ? <p>Sensitive data</p> : null}
+ *         <p>Not sensitive data</p>
+ *     );
+ *
+ *     const customRoutes = [
+ *         <Route path="/foo" element={
+ *             <WithPermissions
+ *                  authParams={{ foo: 'bar' }}
+ *                  component={({ permissions, ...props }) => <Foo permissions={permissions} {...props} />}
+ *              />
+ *         } />
+ *     ];
+ *     const App = () => (
+ *         <Admin>
+ *             <CustomRoutes>{customRoutes}</CustomRoutes>
+ *         </Admin>
+ *     );
+ */
+const WithPermissions = (props) => {
+    const { authParams, children, render, component, loading: Loading = null, staticContext, ...rest } = props;
+    warning((render && children && !isEmptyChildren(children)) ||
+        (render && component) ||
+        (component && children && !isEmptyChildren(children)), 'You should only use one of the `component`, `render` and `children` props in <WithPermissions>');
+    const { isPending: isAuthenticationPending } = useAuthenticated(authParams);
+    const { permissions, isPending: isPendingPermissions } = usePermissions(authParams, {
+        enabled: !isAuthenticationPending,
+    });
+    // We must check both pending states here as if the authProvider does not implement getPermissions, isPendingPermissions will always be false
+    if (isAuthenticationPending || isPendingPermissions) {
+        return Loading ? _jsx(Loading, {}) : null;
+    }
+    if (component) {
+        return createElement(component, { permissions, ...rest });
+    }
+    // @deprecated
+    if (render) {
+        return render({ permissions, ...rest });
+    }
+    // @deprecated
+    if (children) {
+        return children({ permissions, ...rest });
+    }
+};
+export default WithPermissions;

package/dist/ra-core/src/auth/addRefreshAuthToAuthProvider.d.ts

@@ -0,0 +1,22 @@
+import { AuthProvider } from '../types';
+/**
+ * A higher-order function which wraps an authProvider to handle refreshing authentication.
+ * This is useful when the authentication service supports a refresh token mechanism.
+ * The wrapped provider will call the refreshAuth function before
+ * calling the authProvider checkAuth, getIdentity and getPermissions methods.
+ *
+ * The refreshAuth function should return a Promise that resolves when the authentication token has been refreshed.
+ * It might throw an error if the refresh failed. In this case, react-admin will handle the error as usual.
+ *
+ * @param provider An authProvider
+ * @param refreshAuth A function that refreshes the authentication token if needed and returns a Promise.
+ * @returns A wrapped authProvider.
+ *
+ * @example
+ * import { addRefreshAuthToAuthProvider } from 'react-admin';
+ * import { authProvider } from './authProvider';
+ * import { refreshAuth } from './refreshAuth';
+ *
+ * const authProvider = addRefreshAuthToAuthProvider(authProvider, refreshAuth);
+ */
+export declare const addRefreshAuthToAuthProvider: <AuthProviderType extends AuthProvider = AuthProvider>(provider: AuthProviderType, refreshAuth: () => Promise<void>) => AuthProviderType;

package/dist/ra-core/src/auth/addRefreshAuthToAuthProvider.js

@@ -0,0 +1,41 @@
+/**
+ * A higher-order function which wraps an authProvider to handle refreshing authentication.
+ * This is useful when the authentication service supports a refresh token mechanism.
+ * The wrapped provider will call the refreshAuth function before
+ * calling the authProvider checkAuth, getIdentity and getPermissions methods.
+ *
+ * The refreshAuth function should return a Promise that resolves when the authentication token has been refreshed.
+ * It might throw an error if the refresh failed. In this case, react-admin will handle the error as usual.
+ *
+ * @param provider An authProvider
+ * @param refreshAuth A function that refreshes the authentication token if needed and returns a Promise.
+ * @returns A wrapped authProvider.
+ *
+ * @example
+ * import { addRefreshAuthToAuthProvider } from 'react-admin';
+ * import { authProvider } from './authProvider';
+ * import { refreshAuth } from './refreshAuth';
+ *
+ * const authProvider = addRefreshAuthToAuthProvider(authProvider, refreshAuth);
+ */
+export const addRefreshAuthToAuthProvider = (provider, refreshAuth) => {
+    const proxy = new Proxy(provider, {
+        get(_, name) {
+            const shouldIntercept = AuthProviderInterceptedMethods.includes(name.toString()) &&
+                provider[name.toString()] != null;
+            if (shouldIntercept) {
+                return async (...args) => {
+                    await refreshAuth();
+                    return provider[name.toString()](...args);
+                };
+            }
+            return provider[name.toString()];
+        },
+    });
+    return proxy;
+};
+const AuthProviderInterceptedMethods = [
+    'checkAuth',
+    'getIdentity',
+    'getPermissions',
+];

package/dist/ra-core/src/auth/addRefreshAuthToDataProvider.d.ts

@@ -0,0 +1,21 @@
+import { DataProvider } from '../types';
+/**
+ * A higher-order function which wraps a dataProvider to handle refreshing authentication.
+ * This is useful when the authentication service supports a refresh token mechanism.
+ * The wrapped provider will call the refreshAuth function before calling any dataProvider methods.
+ *
+ * The refreshAuth function should return a Promise that resolves when the authentication token has been refreshed.
+ * It might throw an error if the refresh failed. In this case, react-admin will handle the error as usual.
+ *
+ * @param provider A dataProvider
+ * @param refreshAuth A function that refreshes the authentication token if needed and returns a Promise.
+ * @returns A wrapped dataProvider.
+ *
+ * @example
+ * import { addRefreshAuthToDataProvider } from 'react-admin';
+ * import { jsonServerProvider } from 'ra-data-json-server';
+ * import { refreshAuth } from './refreshAuth';
+ *
+ * const dataProvider = addRefreshAuthToDataProvider(jsonServerProvider('http://localhost:3000'), refreshAuth);
+ */
+export declare const addRefreshAuthToDataProvider: <DataProviderType extends DataProvider = DataProvider>(provider: DataProviderType, refreshAuth: () => Promise<void>) => DataProviderType;

package/dist/ra-core/src/auth/addRefreshAuthToDataProvider.js

@@ -0,0 +1,30 @@
+/**
+ * A higher-order function which wraps a dataProvider to handle refreshing authentication.
+ * This is useful when the authentication service supports a refresh token mechanism.
+ * The wrapped provider will call the refreshAuth function before calling any dataProvider methods.
+ *
+ * The refreshAuth function should return a Promise that resolves when the authentication token has been refreshed.
+ * It might throw an error if the refresh failed. In this case, react-admin will handle the error as usual.
+ *
+ * @param provider A dataProvider
+ * @param refreshAuth A function that refreshes the authentication token if needed and returns a Promise.
+ * @returns A wrapped dataProvider.
+ *
+ * @example
+ * import { addRefreshAuthToDataProvider } from 'react-admin';
+ * import { jsonServerProvider } from 'ra-data-json-server';
+ * import { refreshAuth } from './refreshAuth';
+ *
+ * const dataProvider = addRefreshAuthToDataProvider(jsonServerProvider('http://localhost:3000'), refreshAuth);
+ */
+export const addRefreshAuthToDataProvider = (provider, refreshAuth) => {
+    const proxy = new Proxy(provider, {
+        get(_, name) {
+            return async (...args) => {
+                await refreshAuth();
+                return provider[name.toString()](...args);
+            };
+        },
+    });
+    return proxy;
+};

package/dist/ra-core/src/auth/convertLegacyAuthProvider.d.ts

@@ -0,0 +1,12 @@
+import { AuthProvider, LegacyAuthProvider } from '../types';
+/**
+ * Turn a function-based authProvider to an object-based one
+ *
+ * Allows using legacy authProviders transparently.
+ *
+ * @param {Function} legacyAuthProvider A legacy authProvider (type, params) => Promise<any>
+ *
+ * @returns {Object} An authProvider that react-admin can use
+ */
+declare const _default: (legacyAuthProvider: LegacyAuthProvider) => AuthProvider;
+export default _default;

package/dist/ra-core/src/auth/convertLegacyAuthProvider.js

@@ -0,0 +1,19 @@
+import { AUTH_LOGIN, AUTH_LOGOUT, AUTH_CHECK, AUTH_ERROR, AUTH_GET_PERMISSIONS, } from './types';
+/**
+ * Turn a function-based authProvider to an object-based one
+ *
+ * Allows using legacy authProviders transparently.
+ *
+ * @param {Function} legacyAuthProvider A legacy authProvider (type, params) => Promise<any>
+ *
+ * @returns {Object} An authProvider that react-admin can use
+ */
+export default (legacyAuthProvider) => {
+    const authProvider = (...args) => legacyAuthProvider.apply(null, args);
+    authProvider.login = params => legacyAuthProvider(AUTH_LOGIN, params);
+    authProvider.logout = params => legacyAuthProvider(AUTH_LOGOUT, params);
+    authProvider.checkAuth = params => legacyAuthProvider(AUTH_CHECK, params);
+    authProvider.checkError = error => legacyAuthProvider(AUTH_ERROR, error);
+    authProvider.getPermissions = params => legacyAuthProvider(AUTH_GET_PERMISSIONS, params);
+    return authProvider;
+};

package/dist/ra-core/src/auth/index.d.ts

@@ -0,0 +1,27 @@
+import useAuthProvider from './useAuthProvider';
+import useAuthState from './useAuthState';
+import usePermissions from './usePermissions';
+import WithPermissions, { WithPermissionsProps } from './WithPermissions';
+import useLogin from './useLogin';
+import useLogout from './useLogout';
+import useGetPermissions from './useGetPermissions';
+import useLogoutIfAccessDenied from './useLogoutIfAccessDenied';
+import convertLegacyAuthProvider from './convertLegacyAuthProvider';
+export * from './Authenticated';
+export * from './AuthContext';
+export * from './CanAccess';
+export * from './LogoutOnMount';
+export * from './types';
+export * from './useAuthenticated';
+export * from './useCanAccess';
+export * from './useCanAccessResources';
+export * from './useCanAccessCallback';
+export * from './useCheckAuth';
+export * from './useGetIdentity';
+export * from './useHandleAuthCallback';
+export * from './useIsAuthPending';
+export * from './useRequireAccess';
+export * from './addRefreshAuthToAuthProvider';
+export * from './addRefreshAuthToDataProvider';
+export { useAuthProvider, convertLegacyAuthProvider, useLogin, useLogout, useGetPermissions, usePermissions, useAuthState, useLogoutIfAccessDenied, WithPermissions, };
+export type { WithPermissionsProps };

package/dist/ra-core/src/auth/index.js

@@ -0,0 +1,34 @@
+import useAuthProvider from './useAuthProvider';
+import useAuthState from './useAuthState';
+import usePermissions from './usePermissions';
+import WithPermissions from './WithPermissions';
+import useLogin from './useLogin';
+import useLogout from './useLogout';
+import useGetPermissions from './useGetPermissions';
+import useLogoutIfAccessDenied from './useLogoutIfAccessDenied';
+import convertLegacyAuthProvider from './convertLegacyAuthProvider';
+export * from './Authenticated';
+export * from './AuthContext';
+export * from './CanAccess';
+export * from './LogoutOnMount';
+export * from './types';
+export * from './useAuthenticated';
+export * from './useCanAccess';
+export * from './useCanAccessResources';
+export * from './useCanAccessCallback';
+export * from './useCheckAuth';
+export * from './useGetIdentity';
+export * from './useHandleAuthCallback';
+export * from './useIsAuthPending';
+export * from './useRequireAccess';
+export * from './addRefreshAuthToAuthProvider';
+export * from './addRefreshAuthToDataProvider';
+export { useAuthProvider, convertLegacyAuthProvider, 
+// low-level hooks for calling a particular verb on the authProvider
+useLogin, useLogout, useGetPermissions, 
+// hooks with state management
+usePermissions, useAuthState, 
+// hook with immediate effect
+useLogoutIfAccessDenied, 
+// components
+WithPermissions, };

package/dist/ra-core/src/auth/types.d.ts

@@ -0,0 +1,7 @@
+export type UserCheck = (payload: object, pathName: string, routeParams?: object) => void;
+export declare const AUTH_LOGIN = "AUTH_LOGIN";
+export declare const AUTH_CHECK = "AUTH_CHECK";
+export declare const AUTH_ERROR = "AUTH_ERROR";
+export declare const AUTH_LOGOUT = "AUTH_LOGOUT";
+export declare const AUTH_GET_PERMISSIONS = "AUTH_GET_PERMISSIONS";
+export type AuthActionType = typeof AUTH_LOGIN | typeof AUTH_LOGOUT | typeof AUTH_ERROR | typeof AUTH_CHECK | typeof AUTH_GET_PERMISSIONS;

package/dist/ra-core/src/auth/types.js

@@ -0,0 +1,5 @@
+export const AUTH_LOGIN = 'AUTH_LOGIN';
+export const AUTH_CHECK = 'AUTH_CHECK';
+export const AUTH_ERROR = 'AUTH_ERROR';
+export const AUTH_LOGOUT = 'AUTH_LOGOUT';
+export const AUTH_GET_PERMISSIONS = 'AUTH_GET_PERMISSIONS';

package/dist/ra-core/src/auth/useAuthProvider.d.ts

@@ -0,0 +1,10 @@
+import { AuthProvider } from '../types';
+export declare const defaultAuthParams: {
+    loginUrl: string;
+    afterLoginUrl: string;
+};
+/**
+ * Get the authProvider stored in the context
+ */
+declare const useAuthProvider: <AuthProviderType extends AuthProvider = AuthProvider>() => AuthProviderType | undefined;
+export default useAuthProvider;

package/dist/ra-core/src/auth/useAuthProvider.js

@@ -0,0 +1,11 @@
+import { useContext } from 'react';
+import { AuthContext } from './AuthContext';
+export const defaultAuthParams = {
+    loginUrl: '/login',
+    afterLoginUrl: '/',
+};
+/**
+ * Get the authProvider stored in the context
+ */
+const useAuthProvider = () => useContext(AuthContext);
+export default useAuthProvider;

package/dist/ra-core/src/auth/useAuthState.d.ts

@@ -0,0 +1,48 @@
+import { QueryObserverResult, UseQueryOptions } from '@tanstack/react-query';
+/**
+ * Hook for getting the authentication status
+ *
+ * Calls the authProvider.checkAuth() method asynchronously.
+ *
+ * The return value updates according to the authProvider request state:
+ *
+ * - isPending: true just after mount, while the authProvider is being called. false once the authProvider has answered.
+ * - authenticated: true while loading. then true or false depending on the authProvider response.
+ *
+ * To avoid rendering a component and force waiting for the authProvider response, use the useAuthState() hook
+ * instead of the useAuthenticated() hook.
+ *
+ * You can render different content depending on the authenticated status.
+ *
+ * @see useAuthenticated()
+ *
+ * @param {Object} params Any params you want to pass to the authProvider
+ *
+ * @param {Boolean} logoutOnFailure: Optional. Whether the user should be logged out if the authProvider fails to authenticate them. False by default.
+ *
+ * @returns The current auth check state. Destructure as { authenticated, error, isPending }.
+ *
+ * @example
+ * import { useAuthState, Loading } from 'react-admin';
+ *
+ * const MyPage = () => {
+ *     const { isPending, authenticated } = useAuthState();
+ *     if (isPending) {
+ *         return <Loading />;
+ *     }
+ *     if (authenticated) {
+ *        return <AuthenticatedContent />;
+ *     }
+ *     return <AnonymousContent />;
+ * };
+ */
+declare const useAuthState: <ErrorType = Error>(params?: any, logoutOnFailure?: boolean, queryOptions?: UseAuthStateOptions<ErrorType>) => UseAuthStateResult<ErrorType>;
+type UseAuthStateOptions<ErrorType = Error> = Omit<UseQueryOptions<boolean, ErrorType>, 'queryKey' | 'queryFn'> & {
+    onSuccess?: (data: boolean) => void;
+    onError?: (err: ErrorType) => void;
+    onSettled?: (data?: boolean, error?: Error) => void;
+};
+export type UseAuthStateResult<ErrorType = Error> = QueryObserverResult<boolean, ErrorType> & {
+    authenticated?: QueryObserverResult<boolean, ErrorType>['data'];
+};
+export default useAuthState;