@korajs/auth 0.4.0 → 0.6.0

package/dist/react.d.ts

@@ -1,294 +1,110 @@
 import * as react from 'react';
 import { ReactNode, ReactElement } from 'react';
-import { A as AuthClient, c as AuthState$1, d as AuthUser, O as OrgClient, e as ClientMembership, C as ClientInvitation, f as ClientOrganization } from './org-client-BVTLKcIk.js';
+import { d as AuthClient, e as AuthState$1, l as AuthUser, O as OAuthAuthorizationOptions, q as OAuthAuthorizationResult, r as OAuthCallbackParams, L as LinkedOAuthAccount, i as AuthSession, s as OrgClient, v as OrgSession, m as ClientMembership, C as ClientInvitation, n as ClientOrganization } from './create-org-session-RsDj9cl4.js';
+export { x as checkOrgPermission } from './create-org-session-RsDj9cl4.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
 import '@korajs/core';
 
-/**
- * Props for the AuthProvider component.
- */
 interface AuthProviderProps {
-    /** The AuthClient instance to provide to child components */
     client: AuthClient;
-    /** Child components that will have access to auth context */
     children: ReactNode;
-    /**
-     * Optional fallback content to render while the auth client is initializing.
-     * If not provided, children are rendered with `isLoading: true` in the context.
-     */
     fallback?: ReactNode;
 }
-/**
- * React context provider that wraps the AuthClient for use with auth hooks.
- *
- * Calls `client.initialize()` on mount to restore any existing session from
- * stored tokens. Subscribes to auth state changes and re-renders children
- * when the state transitions.
- *
- * Must be placed above any component that uses {@link useAuth},
- * {@link useCurrentUser}, or {@link useAuthStatus}.
- *
- * @param props - Provider props including the AuthClient instance and children
- * @returns A React element wrapping children in the AuthContext
- *
- * @example
- * ```typescript
- * import { AuthClient } from '@korajs/auth'
- * import { AuthProvider } from '@korajs/auth/react'
- *
- * const authClient = new AuthClient({ serverUrl: 'http://localhost:3001' })
- *
- * function App() {
- *   return (
- *     <AuthProvider client={authClient} fallback={<div>Loading...</div>}>
- *       <MyApp />
- *     </AuthProvider>
- *   )
- * }
- * ```
- */
 declare function AuthProvider({ client, children, fallback }: AuthProviderProps): ReactElement;
 
-/**
- * Return value of the {@link useAuth} hook.
- */
 interface UseAuthResult {
-    /** Current authenticated user, or null if not signed in */
     user: AuthUser | null;
-    /** Whether the user is currently authenticated */
     isAuthenticated: boolean;
-    /** Whether the auth client is still initializing (restoring session) */
     isLoading: boolean;
-    /** Sign up a new user account */
     signUp: (params: {
         email: string;
         password: string;
         name?: string;
+        deviceId?: string;
+        devicePublicKey?: string;
     }) => Promise<void>;
-    /** Sign in with email and password */
     signIn: (params: {
         email: string;
         password: string;
+        deviceId?: string;
+        devicePublicKey?: string;
     }) => Promise<void>;
-    /** Sign out the current user */
+    signInWithOAuth: (provider: string, options?: OAuthAuthorizationOptions) => Promise<OAuthAuthorizationResult>;
+    completeOAuthSignIn: (provider: string, params: OAuthCallbackParams) => Promise<void>;
+    getOAuthAuthorizationUrl: (provider: string, options?: OAuthAuthorizationOptions) => Promise<OAuthAuthorizationResult>;
+    linkOAuth: (provider: string, params: OAuthCallbackParams) => Promise<LinkedOAuthAccount | null>;
+    listLinkedAccounts: () => Promise<LinkedOAuthAccount[]>;
+    unlinkOAuth: (provider: string) => Promise<void>;
     signOut: () => Promise<void>;
-    /** Last error message from a sign-up, sign-in, or sign-out attempt, or null */
     error: string | null;
+    initError: Error | null;
 }
-/**
- * Auth status information returned by {@link useAuthStatus}.
- */
 interface AuthStatus {
-    /** Current authentication state */
     state: AuthState$1;
-    /** Whether the user is currently authenticated */
     isAuthenticated: boolean;
-    /** Whether the auth client is still initializing */
     isLoading: boolean;
 }
-/**
- * React hook providing full authentication functionality.
- *
- * Returns the current user, loading state, error state, and methods for
- * sign-up, sign-in, and sign-out. Re-renders when auth state changes.
- *
- * Must be used within an {@link AuthProvider}.
- *
- * @returns An object with user info, auth methods, and status flags
- *
- * @example
- * ```typescript
- * function LoginPage() {
- *   const { user, isAuthenticated, isLoading, signIn, error } = useAuth()
- *
- *   if (isLoading) return <div>Loading...</div>
- *   if (isAuthenticated) return <div>Welcome, {user?.name}</div>
- *
- *   return (
- *     <form onSubmit={async (e) => {
- *       e.preventDefault()
- *       await signIn({ email: 'user@example.com', password: 'secret' })
- *     }}>
- *       {error && <p>{error}</p>}
- *       <button type="submit">Sign In</button>
- *     </form>
- *   )
- * }
- * ```
- */
 declare function useAuth(): UseAuthResult;
-/**
- * React hook that returns the currently authenticated user, or null.
- *
- * A lightweight alternative to {@link useAuth} when you only need the user
- * object and do not need auth methods or error state.
- *
- * Must be used within an {@link AuthProvider}.
- *
- * @returns The current AuthUser or null if not authenticated
- *
- * @example
- * ```typescript
- * function UserAvatar() {
- *   const user = useCurrentUser()
- *   if (!user) return null
- *   return <span>{user.name ?? user.email}</span>
- * }
- * ```
- */
 declare function useCurrentUser(): AuthUser | null;
-/**
- * React hook that returns the current authentication status.
- *
- * Re-renders only when the auth state changes, not on every auth event.
- * Use this for status indicators, route guards, and conditional rendering.
- *
- * Must be used within an {@link AuthProvider}.
- *
- * @returns An AuthStatus object with state, isAuthenticated, and isLoading flags
- *
- * @example
- * ```typescript
- * function AuthGuard({ children }: { children: React.ReactNode }) {
- *   const { isAuthenticated, isLoading } = useAuthStatus()
- *   if (isLoading) return <Spinner />
- *   if (!isAuthenticated) return <Navigate to="/login" />
- *   return <>{children}</>
- * }
- * ```
- */
 declare function useAuthStatus(): AuthStatus;
 
 /**
  * Possible authentication states for the client.
- * - 'loading': Initial state while restoring tokens from storage
- * - 'authenticated': User is signed in with a valid session
- * - 'unauthenticated': No valid session exists
  */
 type AuthState = 'loading' | 'authenticated' | 'unauthenticated';
 /**
  * Shape of the value provided by the AuthContext.
- * Includes the AuthClient instance, reactive state, and a loading flag.
  */
 interface AuthContextValue {
-    /** The underlying AuthClient instance for direct access */
     client: AuthClient;
-    /** Current authentication state */
+    session: AuthSession;
     state: AuthState;
-    /** Whether the client is still initializing (restoring session from storage) */
     isLoading: boolean;
 }
 /**
  * React context for Kora authentication.
- *
- * Provides the AuthClient and reactive auth state to child components.
- * Must be provided by an AuthProvider higher in the component tree.
- * Defaults to null — hooks that consume this context throw if it is missing.
  */
 declare const AuthContext: react.Context<AuthContextValue | null>;
 
-/**
- * Shape of the OrgContext value.
- */
 interface OrgContextValue {
-    /** The OrgClient instance */
     client: OrgClient;
+    session: OrgSession;
 }
-/**
- * React context for organization state.
- */
 declare const OrgContext: react.Context<OrgContextValue | null>;
-/**
- * Return value of the {@link useOrg} hook.
- */
 interface UseOrgResult {
-    /** Currently active organization, or null */
     org: ClientOrganization | null;
-    /** Current user's role in the active organization, or null */
     role: string | null;
-    /** Active organization ID, or null */
     orgId: string | null;
-    /** Switch to a different organization */
     switchOrg: (orgId: string) => Promise<void>;
-    /** Create a new organization */
     createOrg: (params: {
         name: string;
         slug?: string;
     }) => Promise<ClientOrganization>;
-    /** Leave the active organization */
     leaveOrg: () => Promise<void>;
-    /** Clear the active organization */
     clearOrg: () => void;
-    /** List all organizations the user belongs to */
     listOrgs: () => Promise<ClientOrganization[]>;
-    /** Last error, or null */
     error: string | null;
 }
-/**
- * React hook for organization management and context switching.
- *
- * Re-renders when the active organization changes.
- *
- * @example
- * ```typescript
- * function OrgSwitcher() {
- *   const { org, switchOrg, listOrgs, error } = useOrg()
- *   const [orgs, setOrgs] = useState<ClientOrganization[]>([])
- *
- *   useEffect(() => { listOrgs().then(setOrgs) }, [listOrgs])
- *
- *   return (
- *     <select value={org?.id ?? ''} onChange={(e) => switchOrg(e.target.value)}>
- *       <option value="">Select org...</option>
- *       {orgs.map(o => <option key={o.id} value={o.id}>{o.name}</option>)}
- *     </select>
- *   )
- * }
- * ```
- */
 declare function useOrg(): UseOrgResult;
-/**
- * Return value of the {@link useOrgMembers} hook.
- */
 interface UseOrgMembersResult {
-    /** Members of the organization (empty until loaded) */
     members: ClientMembership[];
-    /** Whether members are being loaded */
     isLoading: boolean;
-    /** Reload the members list */
     refresh: () => Promise<void>;
-    /** Invite a user by email */
     invite: (email: string, role: string) => Promise<ClientInvitation>;
-    /** Remove a member */
     removeMember: (userId: string) => Promise<void>;
-    /** Update a member's role */
     updateRole: (userId: string, role: string) => Promise<void>;
-    /** Last error, or null */
     error: string | null;
 }
-/**
- * React hook for managing organization members.
- *
- * Automatically loads members when the orgId changes.
- *
- * @param orgId - Organization ID to manage members for
- */
 declare function useOrgMembers(orgId: string): UseOrgMembersResult;
+declare function usePermission(requiredRole: string): boolean;
+
+interface OrgProviderProps {
+    client: OrgClient;
+    children?: ReactNode;
+}
 /**
- * React hook that checks if the current user has a specific role level
- * in the active organization.
- *
- * @param requiredRole - Minimum role required (uses ROLE_HIERARCHY from org-types)
- * @returns true if the user's role is at least requiredRole
- *
- * @example
- * ```typescript
- * function AdminPanel() {
- *   const canManage = usePermission('admin')
- *   if (!canManage) return <p>Access denied</p>
- *   return <AdminSettings />
- * }
- * ```
+ * Provides organization context for {@link useOrg}, {@link useOrgMembers}, and {@link usePermission}.
  */
-declare function usePermission(requiredRole: string): boolean;
+declare function OrgProvider({ client, children }: OrgProviderProps): react_jsx_runtime.JSX.Element;
 
-export { AuthContext, type AuthContextValue, AuthProvider, type AuthProviderProps, type AuthStatus, OrgContext, type OrgContextValue, type UseAuthResult, type UseOrgMembersResult, type UseOrgResult, useAuth, useAuthStatus, useCurrentUser, useOrg, useOrgMembers, usePermission };
+export { AuthContext, type AuthContextValue, AuthProvider, type AuthProviderProps, type AuthStatus, OrgContext, type OrgContextValue, OrgProvider, type OrgProviderProps, type UseAuthResult, type UseOrgMembersResult, type UseOrgResult, useAuth, useAuthStatus, useCurrentUser, useOrg, useOrgMembers, usePermission };