@cloudbase/auth 3.0.0 → 3.0.1

package/dist/esm/index.d.ts

@@ -1,10 +1,11 @@
 import type { ICloudbase, ICloudbaseConfig } from '@cloudbase/types';
 import type { ICloudbaseCache } from '@cloudbase/types/cache';
 import type { ICloudbaseRequest } from '@cloudbase/types/request';
-import type { ICloudbaseAuthConfig, IUser, IUserInfo, ILoginState } from '@cloudbase/types/auth';
-import type { ProviderSubType } from '@cloudbase/oauth/dist/cjs/auth/models';
-import type { authModels, AuthOptions, Credentials } from '@cloudbase/oauth';
-import { CloudbaseOAuth } from '@cloudbase/oauth';
+import type { ICloudbaseAuthConfig, IUser, ILoginState } from '@cloudbase/types/auth';
+import type { AuthOptions, Credentials } from '@cloudbase/oauth';
+import { CloudbaseOAuth, AuthError, authModels } from '@cloudbase/oauth';
+import { CommonRes, DeleteMeReq, GetClaimsRes, GetUserIdentitiesRes, GetUserRes, LinkIdentityReq, LinkIdentityRes, OnAuthStateChangeCallback, ReauthenticateRes, ResendReq, ResendRes, ResetPasswordForEmailRes, ResetPasswordForOldReq, SetSessionReq, SignInAnonymouslyReq, SignInOAuthRes, SignInRes, SignInWithIdTokenReq, SignInWithOAuthReq, SignInWithOtpReq, SignInWithOtpRes, SignInWithPasswordReq, SignUpRes, UnlinkIdentityReq, UpdateUserReq, UpdateUserWithVerificationRes, VerifyOAuthReq, VerifyOtpReq } from './type';
+export type { SignInRes, GetUserRes, CommonRes, SignInWithOtpRes, SignInOAuthRes, GetClaimsRes, ResetPasswordForEmailRes, GetUserIdentitiesRes, LinkIdentityRes, ReauthenticateRes, ResendRes, UpdateUserWithVerificationRes, OnAuthStateChangeCallback, SignInWithPasswordReq, SignInWithIdTokenReq, SignInWithOAuthReq, VerifyOAuthReq, VerifyOtpReq, LinkIdentityReq, UnlinkIdentityReq, UpdateUserReq, SignInWithOtpReq, ResetPasswordForOldReq, ResendReq, SetSessionReq, DeleteMeReq, SignUpRes, } from './type';
 interface UserInfo {
     uid?: string;
     gender?: string;
@@ -24,7 +25,7 @@ interface IUserOptions {
     cache: ICloudbaseCache;
     oauthInstance: CloudbaseOAuth;
 }
-declare class User implements IUser {
+export declare class User implements IUser {
     uid?: string;
     gender?: string;
     picture?: string;
@@ -55,11 +56,11 @@ declare class User implements IUser {
     refresh(params?: {
         version?: string;
         query?: any;
-    }): Promise<IUserInfo>;
-    private getLocalUserInfo;
+    }): Promise<authModels.UserInfo>;
+    getLocalUserInfo(key?: string): string | boolean | Record<string, any>;
+    setLocalUserInfo(userInfo: any): void;
     private getLocalUserInfoAsync;
     private setUserInfo;
-    private setLocalUserInfo;
 }
 interface ILoginStateOptions extends IUserOptions {
     envId: string;
@@ -74,9 +75,11 @@ export declare class LoginState implements ILoginState {
     checkLocalStateAsync(): Promise<void>;
 }
 declare class Auth {
-    private readonly config;
-    private readonly cache;
-    private oauthInstance;
+    readonly config: ICloudbaseAuthConfig;
+    oauthInstance: CloudbaseOAuth;
+    readonly cache: ICloudbaseCache;
+    private listeners;
+    private hasListenerSetUp;
     constructor(config: ICloudbaseAuthConfig & {
         cache: ICloudbaseCache;
         request?: ICloudbaseRequest;
@@ -90,21 +93,12 @@ declare class Auth {
         withCaptcha: boolean;
     }): Promise<authModels.GetVerificationResponse>;
     get currentUser(): User;
-    getCurrentUser(): Promise<User>;
-    signInAnonymously(data?: {
-        provider_token?: string;
-    }): Promise<LoginState>;
+    getCurrentUser(): Promise<(authModels.UserInfo & Partial<User>) | null>;
     signInAnonymouslyInWx({ useWxCloud, }?: {
         useWxCloud?: boolean;
     }): Promise<LoginState>;
     bindOpenId(): Promise<void>;
-    signInWithOpenId({ useWxCloud }?: {
-        useWxCloud?: boolean;
-    }): Promise<LoginState>;
     signInWithUnionId(): Promise<LoginState>;
-    signInWithPhoneAuth({ phoneCode }: {
-        phoneCode?: string;
-    }): Promise<LoginState>;
     signInWithSms({ verificationInfo, verificationCode, phoneNum, bindInfo, }: {
         verificationInfo?: {
             verification_id: string;
@@ -124,17 +118,12 @@ declare class Auth {
         email?: string;
     }): Promise<LoginState>;
     setCustomSignFunc(getTickFn: authModels.GetCustomSignTicketFn): void;
-    signInWithCustomTicket(): Promise<LoginState>;
     signIn(params: authModels.SignInRequest): Promise<LoginState>;
-    signUp(params: authModels.SignUpRequest): Promise<LoginState>;
     setPassword(params: authModels.SetPasswordRequest): Promise<void>;
     isUsernameRegistered(username: string): Promise<boolean>;
-    signOut(params?: authModels.SignoutRequest): Promise<void | authModels.SignoutReponse>;
     hasLoginState(): LoginState | null;
     getLoginState(): Promise<LoginState>;
-    getUserInfo(params?: {
-        version?: string;
-    }): Promise<IUserInfo>;
+    getUserInfo(): Promise<(authModels.UserInfo & Partial<User>) | null>;
     getWedaUserInfo(): Promise<any>;
     updateUserBasicInfo(params: authModels.ModifyUserBasicInfoRequest): Promise<void>;
     getAuthHeader(): {};
@@ -163,7 +152,7 @@ declare class Auth {
     }): Promise<Credentials>;
     getCredentials(): Promise<Credentials>;
     setCredentials(credentials: Credentials): Promise<void>;
-    getProviderSubType(): Promise<ProviderSubType>;
+    getProviderSubType(): Promise<authModels.ProviderSubType>;
     createCaptchaData(params: {
         state: string;
         redirect_uri?: string;
@@ -183,12 +172,96 @@ declare class Auth {
     modifyPassword(params: authModels.ModifyUserBasicInfoRequest): Promise<void>;
     modifyPasswordWithoutLogin(params: authModels.ModifyPasswordWithoutLoginRequest): Promise<void>;
     getUserBehaviorLog(params: authModels.GetUserBehaviorLog): Promise<authModels.GetUserBehaviorLogRes>;
-    toDefaultLoginPage(params?: authModels.ToDefaultLoginPage): Promise<void>;
-    private createLoginState;
-    private signInWithUsername;
+    signInWithUsername({ verificationInfo, verificationCode, username: rawUsername, bindInfo, loginType, }: {
+        verificationInfo?: authModels.GetVerificationResponse;
+        verificationCode?: string;
+        username?: string;
+        bindInfo?: any;
+        loginType?: string;
+    }): Promise<LoginState>;
+    createLoginState(params?: {
+        version?: string;
+        query?: any;
+    }, options?: {
+        asyncRefreshUser?: boolean;
+        userInfo?: any;
+    }): Promise<LoginState>;
+    setAccessKey(): Promise<void>;
+    signInAnonymously(params: SignInAnonymouslyReq): Promise<SignInRes>;
+    signUp(params: authModels.SignUpRequest & {
+        phone?: string;
+    }): Promise<SignUpRes>;
+    signOut(params?: authModels.SignoutRequest): Promise<authModels.SignoutResponse & {
+        data: Object;
+        error: AuthError;
+    }>;
+    onAuthStateChange(callback: OnAuthStateChangeCallback): {
+        data: {
+            subscription: {
+                id: string;
+                callback: OnAuthStateChangeCallback;
+                unsubscribe: () => void;
+            };
+        };
+    };
+    signInWithPassword(params: SignInWithPasswordReq): Promise<SignInRes>;
+    signInWithIdToken(params: SignInWithIdTokenReq): Promise<SignInRes>;
+    signInWithOtp(params: SignInWithOtpReq): Promise<SignInWithOtpRes>;
+    verifyOAuth(params?: VerifyOAuthReq): Promise<SignInRes | LinkIdentityRes>;
+    signInWithOAuth(params: SignInWithOAuthReq): Promise<SignInOAuthRes>;
+    getClaims(): Promise<GetClaimsRes>;
+    resetPasswordForEmail(emailOrPhone: string, options?: {
+        redirectTo?: string;
+    }): Promise<ResetPasswordForEmailRes>;
+    resetPasswordForOld(params: ResetPasswordForOldReq): Promise<{
+        data: {
+            user: import("./type").User;
+            session: import("./type").Session;
+        };
+        error: any;
+    } | {
+        data: {
+            user?: undefined;
+            session?: undefined;
+        };
+        error: AuthError;
+    }>;
+    verifyOtp(params: VerifyOtpReq): Promise<SignInRes>;
+    getSession(): Promise<SignInRes>;
+    refreshSession(refresh_token?: string): Promise<SignInRes>;
+    getUser(): Promise<GetUserRes>;
+    refreshUser(): Promise<CommonRes>;
+    updateUser(params: UpdateUserReq): Promise<GetUserRes | UpdateUserWithVerificationRes>;
+    getUserIdentities(): Promise<GetUserIdentitiesRes>;
+    linkIdentity(params: LinkIdentityReq): Promise<LinkIdentityRes>;
+    unlinkIdentity(params: UnlinkIdentityReq): Promise<CommonRes>;
+    reauthenticate(): Promise<ReauthenticateRes>;
+    resend(params: ResendReq): Promise<ResendRes>;
+    setSession(params: SetSessionReq): Promise<SignInRes>;
+    exchangeCodeForSession(): Promise<void>;
+    deleteUser(params: DeleteMeReq): Promise<CommonRes>;
+    toDefaultLoginPage(params?: authModels.ToDefaultLoginPage): Promise<CommonRes>;
+    signInWithCustomTicket(getTickFn?: authModels.GetCustomSignTicketFn): Promise<SignInRes>;
+    signInWithOpenId({ useWxCloud }?: {
+        useWxCloud?: boolean;
+    }): Promise<SignInRes>;
+    signInWithPhoneAuth({ phoneCode }: {
+        phoneCode?: string;
+    }): Promise<SignInRes>;
+    private formatPhone;
+    private notifyListeners;
+    private setupListeners;
+    private convertToUser;
+    private validateParams;
+    private validateAtLeastOne;
+    private init;
 }
-type TInitAuthOptions = Pick<ICloudbaseAuthConfig, 'region' | 'persistence' | 'i18n' | 'publishable_key'> & Partial<AuthOptions>;
-export declare function generateAuthInstance(config: TInitAuthOptions, options?: {
+type TInitAuthOptions = Pick<ICloudbaseAuthConfig, 'region' | 'persistence' | 'i18n' | 'accessKey' | 'useWxCloud'> & Partial<AuthOptions> & {
+    detectSessionInUrl?: boolean;
+};
+export declare function generateAuthInstance(config: TInitAuthOptions & {
+    sdkVersion?: string;
+}, options?: {
     clientId: ICloudbaseConfig['clientId'];
     env: ICloudbaseConfig['env'];
     apiOrigin: string;
@@ -196,6 +269,7 @@ export declare function generateAuthInstance(config: TInitAuthOptions, options?:
     platform?: ICloudbase['platform'];
     app?: ICloudbase;
     debug?: ICloudbaseAuthConfig['debug'];
+    detectSessionInUrl?: ICloudbaseAuthConfig['detectSessionInUrl'];
 }): {
     authInstance: Auth;
     oauthInstance: CloudbaseOAuth;