@choiceform/shared-auth 0.1.16 → 0.1.18

package/dist/components/auth-sync.js

@@ -0,0 +1,117 @@
+/**
+ * Better Auth 认证状态同步组件
+ *
+ * 功能说明：
+ * - 同步 better-auth 的 session 状态到 Legend State store
+ * - 在用户登录成功后自动设置组织/团队上下文
+ * - 使用响应式状态监听，确保状态同步的实时性
+ *
+ * 边缘情况处理：
+ * - Session 加载中：设置 loading 状态
+ * - Session 错误：清空用户信息，重置团队设置状态
+ * - 无 Session 但有用户：保持用户信息（可能从 token 加载）
+ * - 用户登出：重置团队设置状态，允许下次登录时重新设置
+ */
+import { useEffect, useRef, useCallback } from "react";
+import { use$ } from "@legendapp/state/react";
+import { mapToSessionUser } from "../utils";
+import { setupCompanionTeam } from "../services";
+/**
+ * 将 Better Auth session 数据映射为 SessionUser
+ */
+function mapBetterAuthSession(user, session) {
+    return mapToSessionUser({
+        banExpires: user.banExpires,
+        banReason: user.banReason,
+        banned: user.banned,
+        createdAt: user.createdAt,
+        email: user.email,
+        emailVerified: user.emailVerified,
+        id: user.id,
+        image: user.image,
+        name: user.name,
+        role: user.role,
+        updatedAt: user.updatedAt,
+    }, {
+        activeOrganizationId: session?.activeOrganizationId,
+        activeTeamId: session?.activeTeamId,
+        createdAt: session?.createdAt,
+    });
+}
+/**
+ * AuthSync 组件
+ */
+export function AuthSync({ auth }) {
+    const { authClient, authActions, tokenStorage, authStore } = auth;
+    // 监听 authStore 中的用户状态（响应式）
+    const user = use$(authStore.user);
+    const isAuthenticated = use$(authStore.isAuthenticated);
+    const isLoaded = use$(authStore.isLoaded);
+    // 监听 better-auth 的 session
+    const sessionResult = authClient.useSession();
+    const { data: session, isPending, error, refetch } = sessionResult || {
+        data: null,
+        isPending: false,
+        error: null,
+        refetch: undefined,
+    };
+    // 确保 companion team 设置只执行一次
+    const teamSetupRef = useRef(false);
+    // 处理 session 更新
+    const handleSessionUpdate = useCallback((sessionData) => {
+        if (sessionData?.user) {
+            try {
+                const mappedUser = mapBetterAuthSession(sessionData.user, sessionData.session);
+                authActions.initialize(mappedUser, true);
+            }
+            catch (mappingError) {
+                console.error("[AuthSync] Failed to map session user:", mappingError);
+            }
+        }
+    }, [authActions]);
+    // Effect 1: 同步 better-auth session 到 store
+    useEffect(() => {
+        if (isPending) {
+            authActions.setLoading(true);
+            return;
+        }
+        authActions.setLoading(false);
+        if (error) {
+            const errorMessage = error instanceof Error
+                ? error.message
+                : typeof error === "string"
+                    ? error
+                    : "Authentication error";
+            authActions.setError(errorMessage);
+            authActions.initialize(null, true);
+            teamSetupRef.current = false;
+            return;
+        }
+        if (session) {
+            handleSessionUpdate(session);
+        }
+    }, [session, isPending, error, authActions, handleSessionUpdate]);
+    // Effect 2: 设置 companion team
+    useEffect(() => {
+        // 只有在用户已认证且已加载完成时才设置
+        if (isLoaded && isAuthenticated && user?.id && !teamSetupRef.current) {
+            teamSetupRef.current = true;
+            const token = tokenStorage.get();
+            if (token && typeof token === "string" && token.trim().length > 0) {
+                setupCompanionTeam(auth, token, {
+                    onComplete: () => refetch?.(),
+                    onError: () => {
+                        // 失败后重置，允许重试
+                        teamSetupRef.current = false;
+                    },
+                });
+            }
+        }
+        // 用户登出：重置 ref
+        if (isLoaded && !isAuthenticated) {
+            teamSetupRef.current = false;
+        }
+    }, [user, isAuthenticated, isLoaded, auth, tokenStorage, refetch]);
+    // 不渲染任何内容
+    return null;
+}

package/dist/components/protected-route.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import type { AuthInstance } from "../core";
+interface ProtectedRouteProps {
+    auth: AuthInstance;
+    children: React.ReactNode;
+    loadingComponent?: React.ComponentType<{
+        message?: string;
+    }>;
+    loadingMessage?: string;
+    onUnauthorized: () => void;
+}
+/**
+ * 路由保护组件
+ * 等待认证初始化完成，根据认证状态进行路由保护
+ */
+export declare const ProtectedRoute: React.FC<ProtectedRouteProps>;
+export default ProtectedRoute;
+//# sourceMappingURL=protected-route.d.ts.map

package/dist/components/protected-route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protected-route.d.ts","sourceRoot":"","sources":["../../src/components/protected-route.tsx"],"names":[],"mappings":"AACA,OAAO,KAAoB,MAAM,OAAO,CAAA;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAE3C,UAAU,mBAAmB;IAC3B,IAAI,EAAE,YAAY,CAAA;IAClB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,gBAAgB,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,cAAc,EAAE,MAAM,IAAI,CAAA;CAC3B;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAgCxD,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/components/protected-route.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { observer } from "@legendapp/state/react";
+import { useEffect } from "react";
+/**
+ * 路由保护组件
+ * 等待认证初始化完成，根据认证状态进行路由保护
+ */
+export const ProtectedRoute = observer(({ children, auth, loadingComponent, loadingMessage, onUnauthorized }) => {
+    const { authStore, authComputed } = auth;
+    // 检查各种状态
+    const isInitializing = authComputed.isInitializing.get();
+    const isAuthenticated = authStore.isAuthenticated.get();
+    // 当未认证时调用回调
+    useEffect(() => {
+        if (!isInitializing && !isAuthenticated) {
+            onUnauthorized();
+        }
+    }, [isInitializing, isAuthenticated, onUnauthorized]);
+    // 检查初始化状态
+    if (isInitializing) {
+        if (loadingComponent) {
+            const LoadingComponent = loadingComponent;
+            return _jsx(LoadingComponent, { message: loadingMessage });
+        }
+        return _jsx("div", { children: loadingMessage || "Checking authentication..." });
+    }
+    // 检查认证状态
+    if (!isAuthenticated) {
+        return null;
+    }
+    // 所有检查通过，渲染子组件
+    return _jsx(_Fragment, { children: children });
+});
+export default ProtectedRoute;

package/dist/components/sign-in-page.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+import type { AuthInstance } from "../core";
+interface SignInPageProps {
+    afterElement?: React.ReactNode;
+    auth: AuthInstance;
+    beforeElement?: React.ReactNode;
+    className?: string;
+    description?: string;
+    footerText?: React.ReactNode;
+    githubButton?: (isSigningIn: boolean) => React.ReactNode;
+    onAuthSuccess?: () => void;
+    provider?: string;
+    redirectUrl?: string;
+    title?: string;
+}
+/**
+ * 登录页面组件
+ */
+export declare function SignInPage({ afterElement, auth, beforeElement, onAuthSuccess, redirectUrl, provider, title, description, githubButton, className, footerText, }: SignInPageProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=sign-in-page.d.ts.map

package/dist/components/sign-in-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sign-in-page.d.ts","sourceRoot":"","sources":["../../src/components/sign-in-page.tsx"],"names":[],"mappings":"AAEA,OAAO,KAA8B,MAAM,OAAO,CAAA;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAE3C,UAAU,eAAe;IACvB,YAAY,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC9B,IAAI,EAAE,YAAY,CAAA;IAClB,aAAa,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC5B,YAAY,CAAC,EAAE,CAAC,WAAW,EAAE,OAAO,KAAK,KAAK,CAAC,SAAS,CAAA;IACxD,aAAa,CAAC,EAAE,MAAM,IAAI,CAAA;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,EACzB,YAAY,EACZ,IAAI,EACJ,aAAa,EACb,aAAa,EACb,WAA0B,EAC1B,QAAmB,EACnB,KAAK,EACL,WAAW,EACX,YAAY,EACZ,SAAS,EACT,UAAU,GACX,EAAE,eAAe,2CA+CjB"}

package/dist/components/sign-in-page.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Slot } from "@choiceform/design-system";
+import { use$ } from "@legendapp/state/react";
+import { useEffect, useState } from "react";
+/**
+ * 登录页面组件
+ */
+export function SignInPage({ afterElement, auth, beforeElement, onAuthSuccess, redirectUrl = "/community", provider = "github", title, description, githubButton, className, footerText, }) {
+    const { authStore, authActions } = auth;
+    const { isAuthenticated, error } = use$(authStore);
+    const [isSigningIn, setIsSigningIn] = useState(false);
+    useEffect(() => {
+        if (isAuthenticated && onAuthSuccess) {
+            onAuthSuccess();
+        }
+    }, [isAuthenticated, onAuthSuccess]);
+    const handleSignIn = async () => {
+        // 设置本地 loading 状态
+        setIsSigningIn(true);
+        try {
+            await authActions.signIn(provider, `${window.location.origin}${redirectUrl}`);
+            // OAuth 会重定向，所以这里的代码可能不会执行
+            // loading 状态会在页面刷新后重置
+        }
+        catch (error) {
+            // 如果出错，重置 loading 状态
+            setIsSigningIn(false);
+        }
+    };
+    return (_jsxs("div", { className: className, children: [beforeElement, title && (_jsxs("div", { className: "flex flex-col gap-2", children: [title && _jsx("p", { className: "text-heading-large", children: title }), description && (_jsx("p", { className: "text-secondary-foreground text-body-large", children: description }))] })), provider === "github" && (_jsx(Slot, { onClick: handleSignIn, children: githubButton?.(isSigningIn) })), error && _jsx("p", { className: "text-danger-foreground mt-2", children: error }), footerText, afterElement] }));
+}

package/dist/config.js

@@ -9,5 +9,5 @@ export const defaultAuthConfig = {
     getSessionEndpoint: "/v1/auth/get-session",
     plugins: [],
     skipTokenCleanupOnError: false,
-    tokenStorageKey: "auth-token",
+    tokenStorageKey: "oneauth_token",
 };

package/dist/core.d.ts

@@ -1,18 +1,28 @@
 /**
  * 认证系统核心
+ *
+ * 架构设计：
+ * - Store Layer: 响应式状态管理（authStore + storeActions）
+ * - Service Layer: 业务逻辑（authService）
+ * - API Layer: HTTP 请求（apiClient + authApi/organizationApi/teamApi）
+ *
+ * 使用方式：
+ * ```typescript
+ * // 初始化
+ * const auth = createAuth({ baseURL: 'https://api.example.com' })
+ *
+ * // 响应式读取状态
+ * const user = use$(auth.authStore.user)
+ *
+ * // 业务操作
+ * await auth.authService.signInWithEmail(email, password)
+ *
+ * // 状态更新
+ * auth.storeActions.setUser(user)
+ * ```
  */
-import type { AuthConfig } from "./types";
+import type { AuthConfig, Organization, SetActiveOrganizationRequest, SetActiveTeamRequest } from "./types";
 export declare function createAuth(config: AuthConfig): {
-    getCurrentUser: () => import("./types").SessionUser | null;
-    getCurrentUserId: () => string | null;
-    isAuthenticated: () => boolean;
-    isLoading: () => boolean;
-    isLoaded: () => boolean;
-    waitForAuth: () => Promise<void>;
-    getAuthToken: () => Promise<string | null>;
-    getAuthTokenSync: () => string | null;
-    getAuthHeaders: () => Promise<Record<string, string>>;
-    getAuthHeadersSync: () => Record<string, string>;
     apiClient: {
         get<T = unknown>(path: string, options?: RequestInit): Promise<import("./api").ApiResponse<T>>;
         post<T = unknown>(path: string, body?: unknown, options?: RequestInit): Promise<import("./api").ApiResponse<T>>;
@@ -20,37 +30,131 @@ export declare function createAuth(config: AuthConfig): {
         delete<T = unknown>(path: string, options?: RequestInit): Promise<import("./api").ApiResponse<T>>;
         fetch(path: string, options?: RequestInit): Promise<Response>;
     };
-    userManager: {
-        getUser: () => import("./types").SessionUser | null;
-        getUserId: () => string | null;
-    };
-    authActions: {
-        initialize(user: import("./types").SessionUser | null, isLoaded: boolean): Promise<void>;
-        fetchSessionWithToken(token: string): Promise<void>;
-        handleUnauthorized(): void;
-        setLoading(loading: boolean): void;
-        setError(error: string | null): void;
-        signIn(provider: string, callbackURL: string, newUserCallbackURL?: string, errorCallbackURL?: string): Promise<void>;
-        signInWithMagicLink(email: string, callbackURL: string, name?: string, newUserCallbackURL?: string): Promise<boolean>;
-        signInWithEmail(email: string, password: string): Promise<boolean>;
-        signUpWithEmail(email: string, password: string, name: string): Promise<boolean>;
-        signOut(redirectTo?: string): Promise<void>;
-        updateUser(user: import("./types").SessionUser | null): void;
-        getUser(): import("./types").SessionUser | null;
-    };
     authApi: {
-        getSession(token?: string): Promise<import("./types").SessionUser | null>;
+        getSession(): Promise<import("./types").SessionUser | null>;
         getSessionWithToken(token: string): Promise<import("./types").SessionUser | null>;
-        setActiveOrganization(params: import("./types").SetActiveOrganizationRequest, token?: string): Promise<void>;
-        setActiveTeam(params: import("./types").SetActiveTeamRequest, token?: string): Promise<void>;
         onboard(token: string): Promise<void>;
         updateUser(data: import("./types").UpdateUserRequest): Promise<import("./types").SessionUser | null>;
         sendMagicLink(params: import("./types").MagicLinkRequest): Promise<{
             status: boolean;
         }>;
-        linkCredential(newPassword: string, token?: string): Promise<void>;
+        resendVerificationEmail(email: string, callbackURL?: string): Promise<{
+            status: boolean;
+        }>;
         checkEmailExists(email: string): Promise<boolean>;
+        linkCredential(newPassword: string, token?: string): Promise<void>;
+        changePassword(currentPassword: string, newPassword: string, token?: string): Promise<{
+            success: boolean;
+        }>;
+        changeEmail(newEmail: string, callbackURL?: string, token?: string): Promise<{
+            success: boolean;
+        }>;
+        listAccounts(token?: string): Promise<import("./types").Account[]>;
+        getOAuthAccountInfo(accountId: string, token?: string): Promise<import("./types").OAuthAccountInfo | null>;
+        unlinkAccount(providerId: string, accountId?: string, token?: string): Promise<{
+            success: boolean;
+        }>;
+        deleteUser(password?: string, callbackURL?: string, token?: string): Promise<{
+            message: string;
+            success: boolean;
+        }>;
+        listSessions(token?: string): Promise<import("./types").UserSession[]>;
+        revokeSession(params: import("./types").RevokeSessionRequest, token?: string): Promise<{
+            success: boolean;
+        }>;
+    };
+    organizationApi: {
+        create(request: import("./types").CreateOrganizationRequest): Promise<Organization>;
+        update(request: import("./types").UpdateOrganizationRequest): Promise<Organization>;
+        delete(request: import("./types").DeleteOrganizationRequest): Promise<string>;
+        list(): Promise<Organization[]>;
+        getFullOrganization(): Promise<import("./types").FullOrganization | null>;
+        checkSlug(request: import("./types").CheckSlugRequest): Promise<boolean>;
+        getActiveMember(): Promise<import("./types").Member | null>;
+        getActiveMemberRole(): Promise<{
+            role: string;
+        } | null>;
+        removeMember(request: import("./types").RemoveMemberRequest): Promise<import("./types").Member>;
+        updateMemberRole(request: import("./types").UpdateMemberRoleRequest): Promise<import("./types").Member>;
+        inviteMember(request: import("./types").InviteMemberRequest): Promise<import("./types").Invitation>;
+        listInvitations(): Promise<import("./types").Invitation[]>;
+        getInvitation(invitationId: string): Promise<import("./types").InvitationDetail | null>;
+        cancelInvitation(request: import("./types").CancelInvitationRequest): Promise<void>;
+        acceptInvitation(request: import("./types").AcceptInvitationRequest): Promise<import("./types").InvitationResponse>;
+        rejectInvitation(request: import("./types").RejectInvitationRequest): Promise<import("./types").InvitationResponse>;
+        leave(organizationId: string): Promise<void>;
+    };
+    teamApi: {
+        create(request: import("./types").CreateTeamRequest): Promise<import("./types").Team>;
+        list(): Promise<import("./types").Team[]>;
+        update(request: import("./types").UpdateTeamRequest): Promise<import("./types").Team>;
+        delete(request: import("./types").DeleteTeamRequest): Promise<void>;
+        listUserTeams(): Promise<import("./types").Team[]>;
+        listMembers(teamId: string): Promise<import("./types").TeamMember[]>;
+        addMember(request: import("./types").AddTeamMemberRequest): Promise<import("./types").TeamMember>;
+        removeMember(request: import("./types").RemoveTeamMemberRequest): Promise<void>;
+        leaveTeam(teamId: string): Promise<void>;
     };
+    authStore: import("@legendapp/state").Observable<import("./types").AuthState>;
+    authComputed: {
+        isInitializing: import("@legendapp/state").ObservableBoolean;
+        isReady: import("@legendapp/state").ObservableBoolean;
+        isUnauthenticated: import("@legendapp/state").ObservableBoolean;
+        hasError: import("@legendapp/state").ObservableBoolean;
+        userId: import("@legendapp/state").ObservablePrimitive<string | null>;
+        userEmail: import("@legendapp/state").ObservablePrimitive<string | null>;
+        userName: import("@legendapp/state").ObservablePrimitive<string | null>;
+        userImage: import("@legendapp/state").ObservablePrimitive<string | null>;
+        emailVerified: import("@legendapp/state").ObservableBoolean;
+        activeOrganizationId: import("@legendapp/state").ObservablePrimitive<string | null>;
+        activeTeamId: import("@legendapp/state").ObservablePrimitive<string | null>;
+        inherentOrganizationId: import("@legendapp/state").ObservablePrimitive<string | null>;
+        inherentTeamId: import("@legendapp/state").ObservablePrimitive<string | null>;
+        hasActiveOrganization: import("@legendapp/state").ObservableBoolean;
+        hasActiveTeam: import("@legendapp/state").ObservableBoolean;
+        isInInherentOrganization: import("@legendapp/state").ObservableBoolean;
+        isInInherentTeam: import("@legendapp/state").ObservableBoolean;
+    };
+    tokenStorage: import("./api").TokenStorage;
+    storeActions: {
+        getUser(): import("./types").SessionUser | null;
+        getUserId(): string | null;
+        isAuthenticated(): boolean;
+        isLoading(): boolean;
+        isLoaded(): boolean;
+        setUser(user: import("./types").SessionUser | null): void;
+        updateUser(updates: Partial<import("./types").SessionUser>): void;
+        setLoading(loading: boolean): void;
+        setLoaded(loaded: boolean): void;
+        setError(error: string | null): void;
+        setAuthenticated(user: import("./types").SessionUser): void;
+        clearAuth(): void;
+        handleUnauthorized(): void;
+        setActiveOrganizationId(organizationId: string | null | undefined): void;
+        setActiveTeamId(teamId: string | null | undefined): void;
+        initialize(user: import("./types").SessionUser | null, isLoaded: boolean): void;
+    };
+    authService: {
+        fetchAndSetSession: (token: string) => Promise<import("./types").SessionUser | null>;
+        signInWithOAuth: (provider: string, callbackURL: string, newUserCallbackURL?: string, errorCallbackURL?: string) => Promise<void>;
+        signInWithMagicLink: (email: string, callbackURL: string, name?: string, newUserCallbackURL?: string) => Promise<boolean>;
+        signInWithEmail: (email: string, password: string) => Promise<{
+            emailVerified?: boolean;
+            success: boolean;
+        }>;
+        signUpWithEmail: (email: string, password: string, name: string, callbackURL?: string) => Promise<{
+            emailVerified?: boolean;
+            success: boolean;
+        }>;
+        signOut: (redirectTo?: string) => Promise<void>;
+        deleteUser: (callbackURL: string, password?: string) => Promise<{
+            needsVerification: boolean;
+            success: boolean;
+        }>;
+    };
+    setActiveOrganization: (request: SetActiveOrganizationRequest) => Promise<Organization>;
+    setActiveTeam: (request: SetActiveTeamRequest) => Promise<void>;
+    setActiveOrganizationAndTeam: (organizationId: string, teamId: string) => Promise<Organization>;
     authClient: {
         signIn: {
             social: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
@@ -709,45 +813,18 @@ export declare function createAuth(config: AuthConfig): {
             [x: string]: any;
         };
     };
-    authComputed: {
-        isInitializing: import("@legendapp/state").ObservableBoolean;
-    };
-    authStore: import("@legendapp/state").Observable<import("./types").AuthState>;
-    organizationApi: {
-        create(request: import("./types").CreateOrganizationRequest): Promise<import("./types").Organization>;
-        update(request: import("./types").UpdateOrganizationRequest): Promise<import("./types").Organization>;
-        delete(request: import("./types").DeleteOrganizationRequest): Promise<string>;
-        list(): Promise<import("./types").Organization[]>;
-        getFullOrganization(): Promise<import("./types").FullOrganization | null>;
-        setActive(request: import("./types").SetActiveOrganizationRequest): Promise<import("./types").Organization>;
-        checkSlug(request: import("./types").CheckSlugRequest): Promise<boolean>;
-        getActiveMember(): Promise<import("./types").Member | null>;
-        getActiveMemberRole(): Promise<{
-            role: string;
-        } | null>;
-        removeMember(request: import("./types").RemoveMemberRequest): Promise<import("./types").Member>;
-        updateMemberRole(request: import("./types").UpdateMemberRoleRequest): Promise<import("./types").Member>;
-        inviteMember(request: import("./types").InviteMemberRequest, inviteLink?: string): Promise<import("./types").Invitation>;
-        listInvitations(): Promise<import("./types").Invitation[]>;
-        getInvitation(invitationId: string): Promise<import("./types").InvitationDetail | null>;
-        cancelInvitation(request: import("./types").CancelInvitationRequest): Promise<void>;
-        acceptInvitation(request: import("./types").AcceptInvitationRequest): Promise<import("./types").InvitationResponse>;
-        rejectInvitation(request: import("./types").RejectInvitationRequest): Promise<import("./types").InvitationResponse>;
-        leave(organizationId: string): Promise<void>;
-    };
-    teamApi: {
-        create(request: import("./types").CreateTeamRequest): Promise<import("./types").Team>;
-        list(): Promise<import("./types").Team[]>;
-        update(request: import("./types").UpdateTeamRequest): Promise<import("./types").Team>;
-        delete(request: import("./types").DeleteTeamRequest): Promise<void>;
-        setActive(request: import("./types").SetActiveTeamRequest): Promise<void>;
-        listUserTeams(): Promise<import("./types").Team[]>;
-        listMembers(teamId: string): Promise<import("./types").TeamMember[]>;
-        addMember(request: import("./types").AddTeamMemberRequest): Promise<import("./types").TeamMember>;
-        removeMember(request: import("./types").RemoveTeamMemberRequest): Promise<void>;
-        leaveTeam(teamId: string): Promise<void>;
+    getCurrentUser: () => import("./types").SessionUser | null;
+    getCurrentUserId: () => string | null;
+    isAuthenticated: () => boolean;
+    isLoading: () => boolean;
+    isLoaded: () => boolean;
+    getAuthToken: () => string | null;
+    getAuthHeaders: () => Record<string, string>;
+    waitForAuth: () => Promise<void>;
+    userManager: {
+        getUser: () => import("./types").SessionUser | null;
+        getUserId: () => string | null;
     };
-    tokenStorage: import("./api").TokenStorage;
 };
 export type AuthInstance = ReturnType<typeof createAuth>;
 //# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,KAAK,EAAE,UAAU,EAAyD,MAAM,SAAS,CAAA;AAEhG,wBAAgB,UAAU,CAAC,MAAM,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA+DqpC,CAAC;qBAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA42C,CAAC;;mBAA2D,CAAC;;;;;oBAA8U,CAAC;uBAA8C,CAAC;qBAAmC,CAAC;qBAAmC,CAAC;gBAA+B,CAAC;oBAAuC,CAAC;oBAA2C,CAAC;0BAAwC,CAAC;kBAAwC,CAAC;kBAA8C,CAAC;mBAA+B,CAAC;uBAA0G,CAAC;6BAAuB,CAAC;;mBAAyC,CAAC;;;iBAA2G,CAAC;gBAA+B,CAAC;;;;;;;;;;;;gBAA+e,CAAC;iBAAgB,CAAC;kBAAiB,CAAC;kBAAiB,CAAC;;iBAA8F,CAAC;wBAAkE,CAAC;kBAAgC,CAAC;uBAAmG,CAAC;6BAA2E,CAAC;yBAAwC,CAAC;;;2BAAkF,CAAC;mHAAuL,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAH31J;AAED,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA"}
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AASH,OAAO,KAAK,EACV,UAAU,EAEV,YAAY,EACZ,4BAA4B,EAC5B,oBAAoB,EAIrB,MAAM,SAAS,CAAA;AAEhB,wBAAgB,UAAU,CAAC,MAAM,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA8HX,CAAC;;;;yBAeqrD,CAAC;;;;;;;;;qCAzE5sD,4BAA4B,KACpC,OAAO,CAAC,YAAY,CAAC;6BAUc,oBAAoB,KAAG,OAAO,CAAC,IAAI,CAAC;mDAUxD,MAAM,UACd,MAAM,KACb,OAAO,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA1BH,CAAC;qBAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDxB,CAAC;;mBAEa,CAAC;;;;;oBAYrB,CAAC;uBACL,CAAA;qBACA,CAAH;qBAAmC,CAAC;gBAEnC,CAAH;oBAAuC,CAAC;oBACR,CAAC;0BAId,CAAC;kBACjB,CAAC;kBAA8C,CAAC;mBAA+B,CAAC;uBAA0G,CAAC;6BAAuB,CAAC;;mBAAyC,CAAC;;;iBAA2G,CAAC;gBAA+B,CAAC;;;;;;;;;;;;gBAA+e,CAAC;iBAAgB,CAAC;kBAAiB,CAAC;kBAAiB,CAAC;;iBAA8F,CAAC;wBAAkE,CAAC;kBAAgC,CAAC;uBAAmG,CAAC;6BAA2E,CAAC;yBAAwC,CAAC;;;2BAAkF,CAAC;mHAAuL,CAAC;;;;;;;;;;;;;0BAVjkD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;;EAO7C;AAED,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA"}