analytica-frontend-lib 1.2.24 → 1.2.28

package/dist/AlertManager/index.d.mts

@@ -1,17 +0,0 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { A as AlertsConfig } from '../types-pd3QVhSu.mjs';
-import 'react';
-import '../CheckBoxGroup-9n5C0OH4.mjs';
-
-interface AlertsManagerProps {
-    config: AlertsConfig;
-    isOpen?: boolean;
-    onClose?: () => void;
-    /** URL da imagem após upload (prioritária - será exibida primeiro) */
-    imageLink?: string | null;
-    /** Imagem padrão a ser exibida quando não há imagem selecionada (deve ser URL string - o front deve converter File para URL se necessário) */
-    defaultImage?: string | null;
-}
-declare const AlertsManager: ({ config, isOpen, onClose, imageLink, defaultImage, }: AlertsManagerProps) => react_jsx_runtime.JSX.Element;
-
-export { AlertsManager };

package/dist/AlertManagerView/index.d.mts

@@ -1,31 +0,0 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { a as AlertData } from '../types-pd3QVhSu.mjs';
-import 'react';
-import '../CheckBoxGroup-9n5C0OH4.mjs';
-
-interface AlertViewData extends Omit<AlertData, 'image'> {
-    image?: string;
-    sentAt: string | Date;
-    recipients: RecipientStatus[];
-}
-interface RecipientStatus {
-    id: string;
-    name: string;
-    status: 'viewed' | 'pending';
-}
-interface AlertsManagerViewProps {
-    alertData: AlertViewData;
-    isOpen?: boolean;
-    onClose?: () => void;
-    /** URL da imagem após upload (prioritária - será exibida primeiro) */
-    imageLink?: string | null;
-    /** Imagem padrão a ser exibida quando não há imagem no alertData (URL string) */
-    defaultImage?: string | null;
-    currentPage?: number;
-    totalPages?: number;
-    onPageChange?: (page: number) => void;
-    itemsPerPage?: number;
-}
-declare const AlertsManagerView: ({ alertData, isOpen, onClose, imageLink, defaultImage, currentPage, totalPages: externalTotalPages, onPageChange, itemsPerPage, }: AlertsManagerViewProps) => react_jsx_runtime.JSX.Element;
-
-export { type AlertViewData, AlertsManagerView, type RecipientStatus };

package/dist/Alternative/index.d.mts

@@ -1,81 +0,0 @@
-import * as react from 'react';
-import { HTMLAttributes } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-
-/**
- * Interface para definir uma alternativa
- */
-interface Alternative {
-    value: string;
-    label: string;
-    status?: 'correct' | 'incorrect' | 'neutral';
-    disabled?: boolean;
-    description?: string;
-}
-/**
- * Props do componente AlternativesList
- */
-interface AlternativesListProps {
-    /** Lista de alternativas */
-    alternatives: Alternative[];
-    /** Nome do grupo de radio */
-    name?: string;
-    /** Valor selecionado por padrão */
-    defaultValue?: string;
-    /** Valor controlado */
-    value?: string;
-    /** Callback quando uma alternativa é selecionada */
-    onValueChange?: (value: string) => void;
-    /** Se o componente está desabilitado */
-    disabled?: boolean;
-    /** Layout das alternativas */
-    layout?: 'default' | 'compact' | 'detailed';
-    /** Classes CSS adicionais */
-    className?: string;
-    /** Modo de exibição: interativo (com radios funcionais) ou readonly (apenas visual) */
-    mode?: 'interactive' | 'readonly';
-    /** Valor selecionado pelo usuário (apenas para modo readonly) */
-    selectedValue?: string;
-}
-/**
- * Componente reutilizável para exibir lista de alternativas com RadioGroup
- *
- * Suporta dois modos:
- * - `interactive`: Permite interação com radios (padrão)
- * - `readonly`: Apenas exibição visual dos estados
- *
- * @example
- * ```tsx
- * // Modo interativo (padrão)
- * <AlternativesList
- *   mode="interactive"
- *   alternatives={[
- *     { value: "a", label: "Alternativa A", status: "correct" },
- *     { value: "b", label: "Alternativa B", status: "incorrect" },
- *     { value: "c", label: "Alternativa C" }
- *   ]}
- *   defaultValue="a"
- *   onValueChange={(value) => console.log(value)}
- * />
- *
- * // Modo readonly - mostra seleção do usuário
- * <AlternativesList
- *   mode="readonly"
- *   selectedValue="b"  // O que o usuário selecionou
- *   alternatives={[
- *     { value: "a", label: "Resposta A", status: "correct" },  // Mostra como correta
- *     { value: "b", label: "Resposta B" },  // Mostra radio selecionado + badge incorreto
- *     { value: "c", label: "Resposta C" }
- *   ]}
- * />
- * ```
- */
-declare const AlternativesList: ({ alternatives, name, defaultValue, value, onValueChange, disabled, layout, className, mode, selectedValue, }: AlternativesListProps) => react_jsx_runtime.JSX.Element;
-interface HeaderAlternativeProps extends HTMLAttributes<HTMLDivElement> {
-    title: string;
-    subTitle: string;
-    content: string;
-}
-declare const HeaderAlternative: react.ForwardRefExoticComponent<HeaderAlternativeProps & react.RefAttributes<HTMLDivElement>>;
-
-export { type Alternative, AlternativesList, type AlternativesListProps, HeaderAlternative };

package/dist/Auth/AuthProvider/index.d.mts

@@ -1,3 +0,0 @@
-import 'react/jsx-runtime';
-import 'react';
-export { AuthContextType, AuthProvider, AuthProviderProps, AuthState, AuthTokens, AuthUser, ProtectedRoute, ProtectedRouteProps, PublicRoute, PublicRouteProps, SessionInfo, default, getRootDomain, useAuth, useAuthGuard, useRouteAuth, withAuth } from '../index.mjs';

package/dist/Auth/ProtectedRoute/index.d.mts

@@ -1,3 +0,0 @@
-import 'react/jsx-runtime';
-import 'react';
-export { AuthContextType, AuthProvider, AuthProviderProps, AuthState, AuthTokens, AuthUser, ProtectedRoute, ProtectedRouteProps, PublicRoute, PublicRouteProps, SessionInfo, default, getRootDomain, useAuth, useAuthGuard, useRouteAuth, withAuth } from '../index.mjs';

package/dist/Auth/PublicRoute/index.d.mts

@@ -1,3 +0,0 @@
-import 'react/jsx-runtime';
-import 'react';
-export { AuthContextType, AuthProvider, AuthProviderProps, AuthState, AuthTokens, AuthUser, ProtectedRoute, ProtectedRouteProps, PublicRoute, PublicRouteProps, SessionInfo, default, getRootDomain, useAuth, useAuthGuard, useRouteAuth, withAuth } from '../index.mjs';

package/dist/Auth/getRootDomain/index.d.mts

@@ -1,3 +0,0 @@
-import 'react/jsx-runtime';
-import 'react';
-export { AuthContextType, AuthProvider, AuthProviderProps, AuthState, AuthTokens, AuthUser, ProtectedRoute, ProtectedRouteProps, PublicRoute, PublicRouteProps, SessionInfo, default, getRootDomain, useAuth, useAuthGuard, useRouteAuth, withAuth } from '../index.mjs';

package/dist/Auth/index.d.mts

@@ -1,326 +0,0 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode, ComponentType } from 'react';
-
-/**
- * Interface for basic authentication tokens
- *
- * @interface AuthTokens
- * @property {string} token - Main authentication token
- * @property {string} refreshToken - Token used to refresh the main token
- * @property {unknown} [key] - Additional properties that can be included
- */
-interface AuthTokens {
-    token: string;
-    refreshToken: string;
-    [key: string]: unknown;
-}
-/**
- * Interface for basic user information
- *
- * @interface AuthUser
- * @property {string} id - Unique user identifier
- * @property {string} [name] - Optional user name
- * @property {string} [email] - Optional user email
- * @property {unknown} [key] - Additional user properties
- */
-interface AuthUser {
-    id: string;
-    name?: string;
-    email?: string;
-    [key: string]: unknown;
-}
-/**
- * Interface for basic session information
- *
- * @interface SessionInfo
- * @property {string} [institutionId] - Optional institution identifier
- * @property {string} [profileId] - Optional profile identifier
- * @property {string} [schoolId] - Optional school identifier
- * @property {string} [schoolYearId] - Optional school year identifier
- * @property {string} [classId] - Optional class identifier
- * @property {unknown} [key] - Additional session properties
- */
-interface SessionInfo {
-    institutionId?: string;
-    profileId?: string;
-    schoolId?: string;
-    schoolYearId?: string;
-    classId?: string;
-    [key: string]: unknown;
-}
-/**
- * Interface for authentication state
- *
- * @interface AuthState
- * @property {boolean} isAuthenticated - Whether the user is authenticated
- * @property {boolean} isLoading - Whether authentication is being checked
- * @property {AuthUser | null} [user] - Current user information
- * @property {SessionInfo | null} [sessionInfo] - Current session information
- * @property {AuthTokens | null} [tokens] - Current authentication tokens
- */
-interface AuthState {
-    isAuthenticated: boolean;
-    isLoading: boolean;
-    user?: AuthUser | null;
-    sessionInfo?: SessionInfo | null;
-    tokens?: AuthTokens | null;
-}
-/**
- * Interface for authentication context functions and state
- *
- * @interface AuthContextType
- * @extends {AuthState}
- * @property {() => Promise<boolean>} checkAuth - Function to check authentication status
- * @property {() => void} signOut - Function to sign out the user
- */
-interface AuthContextType extends AuthState {
-    checkAuth: () => Promise<boolean>;
-    signOut: () => void;
-}
-/**
- * Props for the AuthProvider component
- *
- * @interface AuthProviderProps
- * @property {ReactNode} children - Child components
- * @property {() => Promise<boolean> | boolean} [checkAuthFn] - Function to check if user is authenticated
- * @property {() => void} [signOutFn] - Function to handle logout
- * @property {Partial<AuthState>} [initialAuthState] - Initial authentication state
- * @property {() => AuthUser | null | undefined} [getUserFn] - Function to get user data
- * @property {() => SessionInfo | null | undefined} [getSessionFn] - Function to get session info
- * @property {() => AuthTokens | null | undefined} [getTokensFn] - Function to get tokens
- */
-interface AuthProviderProps {
-    children: ReactNode;
-    /**
-     * Função para verificar se o usuário está autenticado
-     * Deve retornar uma Promise<boolean>
-     */
-    checkAuthFn?: () => Promise<boolean> | boolean;
-    /**
-     * Função para fazer logout
-     */
-    signOutFn?: () => void;
-    /**
-     * Estado de autenticação inicial
-     */
-    initialAuthState?: Partial<AuthState>;
-    /**
-     * Função para obter dados do usuário (opcional)
-     */
-    getUserFn?: () => AuthUser | null | undefined;
-    /**
-     * Função para obter informações da sessão (opcional)
-     */
-    getSessionFn?: () => SessionInfo | null | undefined;
-    /**
-     * Função para obter tokens (opcional)
-     */
-    getTokensFn?: () => AuthTokens | null | undefined;
-}
-/**
- * Authentication provider that manages global auth state
- * Compatible with any store (Zustand, Redux, Context, etc.)
- *
- * @param {AuthProviderProps} props - The provider props
- * @returns {JSX.Element} The provider component
- *
- * @example
- * ```tsx
- * <AuthProvider
- *   checkAuthFn={checkAuthFunction}
- *   signOutFn={signOutFunction}
- *   getUserFn={getUserFunction}
- * >
- *   <App />
- * </AuthProvider>
- * ```
- */
-declare const AuthProvider: ({ children, checkAuthFn, signOutFn, initialAuthState, getUserFn, getSessionFn, getTokensFn, }: AuthProviderProps) => react_jsx_runtime.JSX.Element;
-/**
- * Hook to use the authentication context
- *
- * @throws {Error} When used outside of AuthProvider
- * @returns {AuthContextType} The authentication context
- *
- * @example
- * ```tsx
- * const { isAuthenticated, user, signOut } = useAuth();
- * ```
- */
-declare const useAuth: () => AuthContextType;
-/**
- * Props for the ProtectedRoute component
- *
- * @interface ProtectedRouteProps
- * @property {ReactNode} children - Components to render when authenticated
- * @property {string} [redirectTo] - Path to redirect when not authenticated (default: '/')
- * @property {ReactNode} [loadingComponent] - Custom loading component
- * @property {(authState: AuthState) => boolean} [additionalCheck] - Additional authentication check
- */
-interface ProtectedRouteProps {
-    children: ReactNode;
-    /**
-     * Path para redirecionamento quando não autenticado
-     */
-    redirectTo?: string;
-    /**
-     * Componente de loading personalizado
-     */
-    loadingComponent?: ReactNode;
-    /**
-     * Função adicional de verificação (ex: verificar permissões específicas)
-     */
-    additionalCheck?: (authState: AuthState) => boolean;
-}
-/**
- * Componente para proteger rotas que requerem autenticação
- *
- * @example
- * ```tsx
- * <ProtectedRoute redirectTo="/login">
- *   <PainelPage />
- * </ProtectedRoute>
- * ```
- */
-declare const ProtectedRoute: ({ children, redirectTo, loadingComponent, additionalCheck, }: ProtectedRouteProps) => react_jsx_runtime.JSX.Element | null;
-/**
- * Props for the PublicRoute component
- *
- * @interface PublicRouteProps
- * @property {ReactNode} children - Components to render
- * @property {string} [redirectTo] - Path to redirect to (default: '/painel')
- * @property {boolean} [redirectIfAuthenticated] - Whether to redirect if authenticated
- * @property {boolean} [checkAuthBeforeRender] - Whether to check auth before rendering
- */
-interface PublicRouteProps {
-    children: ReactNode;
-    /**
-     * Path para redirecionamento
-     */
-    redirectTo?: string;
-    /**
-     * Se deve redirecionar quando usuário estiver autenticado
-     */
-    redirectIfAuthenticated?: boolean;
-    /**
-     * Se deve verificar autenticação antes de renderizar
-     */
-    checkAuthBeforeRender?: boolean;
-}
-/**
- * Componente para rotas públicas (login, recuperação de senha, etc.)
- * Opcionalmente redireciona se o usuário já estiver autenticado
- *
- * @example
- * ```tsx
- * <PublicRoute redirectTo="/painel" redirectIfAuthenticated={true}>
- *   <LoginPage />
- * </PublicRoute>
- * ```
- */
-declare const PublicRoute: ({ children, redirectTo, redirectIfAuthenticated, checkAuthBeforeRender, }: PublicRouteProps) => react_jsx_runtime.JSX.Element;
-/**
- * Higher-Order Component to protect components with authentication
- *
- * @template P - Component props type
- * @param {ComponentType<P>} Component - Component to wrap with authentication
- * @param {Omit<ProtectedRouteProps, 'children'>} [options] - Protection options
- * @returns {(props: P) => JSX.Element} Wrapped component
- *
- * @example
- * ```tsx
- * const ProtectedComponent = withAuth(MyComponent, {
- *   redirectTo: "/login",
- *   loadingComponent: <CustomSpinner />
- * });
- * ```
- */
-declare const withAuth: <P extends object>(Component: ComponentType<P>, options?: Omit<ProtectedRouteProps, "children">) => (props: P) => react_jsx_runtime.JSX.Element;
-/**
- * Hook for authentication guard with custom checks
- *
- * @param {object} [options] - Guard options
- * @param {boolean} [options.requireAuth=true] - Whether authentication is required
- * @param {(authState: AuthState) => boolean} [options.customCheck] - Custom check function
- * @returns {object} Guard result with canAccess, isLoading, and authState
- *
- * @example
- * ```tsx
- * const { canAccess, isLoading } = useAuthGuard({
- *   requireAuth: true,
- *   customCheck: (authState) => authState.user?.role === 'admin'
- * });
- * ```
- */
-declare const useAuthGuard: (options?: {
-    requireAuth?: boolean;
-    customCheck?: (authState: AuthState) => boolean;
-}) => {
-    canAccess: boolean;
-    isLoading: boolean;
-    authState: AuthContextType;
-};
-/**
- * Hook to check authentication on specific routes
- * Useful for conditional checks within components
- *
- * @param {string} [fallbackPath='/'] - Path to redirect when not authenticated
- * @returns {object} Object with isAuthenticated, isLoading, and redirectToLogin function
- *
- * @example
- * ```tsx
- * const { isAuthenticated, redirectToLogin } = useRouteAuth();
- *
- * if (!isAuthenticated) {
- *   return redirectToLogin();
- * }
- * ```
- */
-declare const useRouteAuth: (fallbackPath?: string) => {
-    isAuthenticated: boolean;
-    isLoading: boolean;
-    redirectToLogin: () => react_jsx_runtime.JSX.Element;
-};
-/**
- * Get the root domain from the current window location
- * Handles localhost, IP addresses, and subdomain cases, including Brazilian .com.br domains
- *
- * @returns {string} The root domain URL
- *
- * @example
- * ```typescript
- * // Domain examples
- * aluno.analiticaensino.com.br -> analiticaensino.com.br
- * subdomain.example.com -> example.com
- *
- * // IP address examples
- * 127.0.0.1:3000 -> 127.0.0.1:3000
- * [::1]:8080 -> [::1]:8080
- *
- * // Localhost examples
- * localhost:3000 -> localhost:3000
- * ```
- */
-declare const getRootDomain: () => string;
-declare const _default: {
-    AuthProvider: ({ children, checkAuthFn, signOutFn, initialAuthState, getUserFn, getSessionFn, getTokensFn, }: AuthProviderProps) => react_jsx_runtime.JSX.Element;
-    ProtectedRoute: ({ children, redirectTo, loadingComponent, additionalCheck, }: ProtectedRouteProps) => react_jsx_runtime.JSX.Element | null;
-    PublicRoute: ({ children, redirectTo, redirectIfAuthenticated, checkAuthBeforeRender, }: PublicRouteProps) => react_jsx_runtime.JSX.Element;
-    withAuth: <P extends object>(Component: ComponentType<P>, options?: Omit<ProtectedRouteProps, "children">) => (props: P) => react_jsx_runtime.JSX.Element;
-    useAuth: () => AuthContextType;
-    useAuthGuard: (options?: {
-        requireAuth?: boolean;
-        customCheck?: (authState: AuthState) => boolean;
-    }) => {
-        canAccess: boolean;
-        isLoading: boolean;
-        authState: AuthContextType;
-    };
-    useRouteAuth: (fallbackPath?: string) => {
-        isAuthenticated: boolean;
-        isLoading: boolean;
-        redirectToLogin: () => react_jsx_runtime.JSX.Element;
-    };
-};
-
-export { type AuthContextType, AuthProvider, type AuthProviderProps, type AuthState, type AuthTokens, type AuthUser, ProtectedRoute, type ProtectedRouteProps, PublicRoute, type PublicRouteProps, type SessionInfo, _default as default, getRootDomain, useAuth, useAuthGuard, useRouteAuth, withAuth };

package/dist/Auth/useApiConfig/index.d.mts

@@ -1,43 +0,0 @@
-/**
- * Type definition for API client with get method
- *
- * @template T - Type extending object with get method
- */
-type ApiClient<T = unknown> = {
-    get: (endpoint: string, config?: T) => Promise<unknown>;
-};
-/**
- * Creates a memoized API configuration object compatible with useUrlAuthentication
- *
- * This hook wraps an API client instance to create a consistent interface
- * for the useUrlAuthentication hook, ensuring proper memoization to prevent
- * unnecessary re-renders.
- *
- * @template T - Generic type for API client configuration
- * @param {ApiClient<T>} api - Axios instance or any API client with a get method
- * @returns {object} Memoized API configuration object with get method
- *
- * @example
- * ```typescript
- * import { useApiConfig } from 'analytica-frontend-lib';
- * import { useApi } from './services/apiService';
- *
- * function App() {
- *   const api = useApi();
- *   const apiConfig = useApiConfig(api);
- *
- *   useUrlAuthentication({
- *     setTokens,
- *     setSessionInfo,
- *     setSelectedProfile,
- *     api: apiConfig,
- *     endpoint: '/auth/session-info',
- *   });
- * }
- * ```
- */
-declare function useApiConfig<T = unknown>(api: ApiClient<T>): {
-    get: (endpoint: string, config: unknown) => Promise<unknown>;
-};
-
-export { useApiConfig };

package/dist/Auth/useAuth/index.d.mts

@@ -1,3 +0,0 @@
-import 'react/jsx-runtime';
-import 'react';
-export { AuthContextType, AuthProvider, AuthProviderProps, AuthState, AuthTokens, AuthUser, ProtectedRoute, ProtectedRouteProps, PublicRoute, PublicRouteProps, SessionInfo, default, getRootDomain, useAuth, useAuthGuard, useRouteAuth, withAuth } from '../index.mjs';

package/dist/Auth/useAuthGuard/index.d.mts

@@ -1,3 +0,0 @@
-import 'react/jsx-runtime';
-import 'react';
-export { AuthContextType, AuthProvider, AuthProviderProps, AuthState, AuthTokens, AuthUser, ProtectedRoute, ProtectedRouteProps, PublicRoute, PublicRouteProps, SessionInfo, default, getRootDomain, useAuth, useAuthGuard, useRouteAuth, withAuth } from '../index.mjs';

package/dist/Auth/useRouteAuth/index.d.mts

@@ -1,3 +0,0 @@
-import 'react/jsx-runtime';
-import 'react';
-export { AuthContextType, AuthProvider, AuthProviderProps, AuthState, AuthTokens, AuthUser, ProtectedRoute, ProtectedRouteProps, PublicRoute, PublicRouteProps, SessionInfo, default, getRootDomain, useAuth, useAuthGuard, useRouteAuth, withAuth } from '../index.mjs';

package/dist/Auth/useUrlAuthentication/index.d.mts

@@ -1,69 +0,0 @@
-/**
- * Options interface for the useUrlAuthentication hook
- *
- * @template Tokens - Type for authentication tokens
- * @template Session - Type for session information
- * @template Profile - Type for profile information
- * @template User - Type for user information
- *
- * @interface UseUrlAuthOptions
- * @property {(tokens: Tokens) => void} setTokens - Function to set authentication tokens
- * @property {(session: Session) => void} setSessionInfo - Function to set session information
- * @property {(profile: Profile) => void} [setSelectedProfile] - Optional function to set selected profile
- * @property {(user: User) => void} [setUser] - Optional function to set user data
- * @property {object} api - API instance with get method
- * @property {(endpoint: string, config: unknown) => Promise<unknown>} api.get - API get method
- * @property {string} endpoint - API endpoint to fetch session data
- * @property {(searchParams: URLSearchParams) => object} [extractParams] - Custom parameter extraction function
- * @property {() => void} [clearParamsFromURL] - Function to clear URL parameters after processing
- * @property {number} [maxRetries] - Maximum number of retry attempts (default: 3)
- * @property {number} [retryDelay] - Base delay between retries in milliseconds (default: 1000)
- * @property {(error: unknown) => void} [onError] - Error handler callback
- */
-interface UseUrlAuthOptions<Tokens = unknown, Session = unknown, Profile = unknown, User = unknown> {
-    setTokens: (tokens: Tokens) => void;
-    setSessionInfo: (session: Session) => void;
-    setSelectedProfile?: (profile: Profile) => void;
-    setUser?: (user: User) => void;
-    api: {
-        get: (endpoint: string, config: unknown) => Promise<unknown>;
-    };
-    endpoint: string;
-    extractParams?: (searchParams: URLSearchParams) => {
-        sessionId: string;
-        token: string;
-        refreshToken: string;
-    };
-    clearParamsFromURL?: () => void;
-    maxRetries?: number;
-    retryDelay?: number;
-    onError?: (error: unknown) => void;
-}
-/**
- * Hook for handling URL-based authentication
- * Extracts authentication parameters from URL and processes them
- *
- * @template Tokens - Type for authentication tokens
- * @template Session - Type for session information
- * @template Profile - Type for profile information
- * @template User - Type for user information
- *
- * @param {UseUrlAuthOptions<Tokens, Session, Profile, User>} options - Configuration options
- * @returns {void}
- *
- * @example
- * ```typescript
- * useUrlAuthentication({
- *   setTokens: (tokens) => authStore.setTokens(tokens),
- *   setSessionInfo: (session) => authStore.setSessionInfo(session),
- *   setSelectedProfile: (profile) => authStore.setProfile(profile),
- *   setUser: (user) => authStore.setUser(user),
- *   api: apiInstance,
- *   endpoint: '/auth/session',
- *   clearParamsFromURL: () => navigate('/', { replace: true })
- * });
- * ```
- */
-declare function useUrlAuthentication<Tokens = unknown, Session = unknown, Profile = unknown, User = unknown>(options: UseUrlAuthOptions<Tokens, Session, Profile, User>): void;
-
-export { type UseUrlAuthOptions, useUrlAuthentication };

package/dist/Auth/withAuth/index.d.mts

@@ -1,3 +0,0 @@
-import 'react/jsx-runtime';
-import 'react';
-export { AuthContextType, AuthProvider, AuthProviderProps, AuthState, AuthTokens, AuthUser, ProtectedRoute, ProtectedRouteProps, PublicRoute, PublicRouteProps, SessionInfo, default, getRootDomain, useAuth, useAuthGuard, useRouteAuth, withAuth } from '../index.mjs';

package/dist/Auth/zustandAuthAdapter/index.d.mts

@@ -1,75 +0,0 @@
-/**
- * Generic adapter for integrating AuthProvider with Zustand stores
- * Users should import this file and pass their store instance
- *
- * @template S - Zustand store type that contains auth-related state
- * @param {object} useAuthStore - Zustand store hook with getState method
- * @param {() => S} useAuthStore.getState - Function to get current store state
- * @returns {object} Adapter object with auth functions
- *
- * @example
- * ```typescript
- * // Define your Zustand store type
- * interface AuthStore {
- *   sessionInfo?: SessionInfo;
- *   tokens?: AuthTokens;
- *   user?: AuthUser;
- *   signOut: () => void;
- * }
- *
- * // Create the adapter
- * const authAdapter = createZustandAuthAdapter(useAuthStore);
- *
- * // Use with AuthProvider
- * <AuthProvider
- *   checkAuthFn={authAdapter.checkAuth}
- *   signOutFn={authAdapter.signOut}
- *   getUserFn={authAdapter.getUser}
- *   getSessionFn={authAdapter.getSessionInfo}
- *   getTokensFn={authAdapter.getTokens}
- * >
- *   <App />
- * </AuthProvider>
- * ```
- */
-declare function createZustandAuthAdapter<S extends {
-    sessionInfo?: unknown;
-    tokens?: unknown;
-    user?: unknown;
-    signOut?: () => void;
-}>(useAuthStore: {
-    getState: () => S;
-}): {
-    /**
-     * Check if the user is authenticated based on sessionInfo and tokens
-     *
-     * @returns {Promise<boolean>} Promise that resolves to authentication status
-     */
-    checkAuth: () => Promise<boolean>;
-    /**
-     * Get the current user from the store
-     *
-     * @returns {unknown} Current user data from the store
-     */
-    getUser: () => unknown;
-    /**
-     * Get the current session information from the store
-     *
-     * @returns {unknown} Current session info from the store
-     */
-    getSessionInfo: () => unknown;
-    /**
-     * Get the current authentication tokens from the store
-     *
-     * @returns {unknown} Current tokens from the store
-     */
-    getTokens: () => unknown;
-    /**
-     * Sign out the user by calling the store's signOut function if available
-     *
-     * @returns {void}
-     */
-    signOut: () => void;
-};
-
-export { createZustandAuthAdapter };