@cloudbase/auth 1.7.3-alpha.0 → 2.0.0-alpha.3

package/dist/esm/index.d.ts

@@ -1,133 +1,85 @@
 import { ICloudbase } from '@cloudbase/types';
-import { events } from '@cloudbase/utilities';
 import { ICloudbaseCache } from '@cloudbase/types/cache';
 import { ICloudbaseRequest } from '@cloudbase/types/request';
-import { ICloudbaseAuthConfig, ICredential, IUser, ILoginState } from '@cloudbase/types/auth';
-import { LOGINTYPE } from './constants';
-import { AuthProvider } from './providers/base';
-import { OAuth2AuthProvider, IOAuth2AuthProviderOptions } from './providers/oauth2AuthProvider';
-import { AnonymousAuthProvider } from './providers/anonymousAuthProvider';
-import { CustomAuthProvider } from './providers/customAuthProvider';
-import { EmailAuthProvider } from './providers/emailAuthProvider';
-import { PhoneAuthProvider } from './providers/phoneAuthProvider';
-import { UsernameAuthProvider } from './providers/usernameAuthProvider';
-import { WeixinAuthProvider } from './providers/weixinAuthProvider';
+import { ICloudbaseAuthConfig, IUser, IUserInfo, ILoginState } from '@cloudbase/types/auth';
+import { authModels, CloudbaseOAuth } from '@cloudbase/oauth';
 interface UserInfo {
-    openid: string;
-    nickname?: string;
-    sex?: number;
-    province?: string;
-    city?: string;
-    country?: string;
-    headimgurl?: string;
-    privilege?: [string];
-    unionid?: string;
+    uid?: string;
+    gender?: string;
+    avatarUrl?: string;
+    picture?: string;
+    email?: string;
+    email_verified?: boolean;
+    phone_number?: string;
+    username?: string;
+    name?: string;
+    birthdate?: string;
+    zoneinfo?: string;
+    locale?: string;
+    sub?: string;
+    created_from?: string;
 }
-declare const eventBus: events.CloudbaseEventEmitter;
 interface IUserOptions {
     cache: ICloudbaseCache;
-    request: ICloudbaseRequest;
+    oauthInstance: CloudbaseOAuth;
 }
 interface ILoginStateOptions extends IUserOptions {
     envId: string;
 }
 export declare class LoginState implements ILoginState {
-    credential: ICredential;
     user: IUser;
+    oauthLoginState: any;
+    private _oauthInstance;
     private _cache;
-    private _loginType;
     constructor(options: ILoginStateOptions);
-    checkLocalState(): Promise<void>;
+    checkLocalState(): void;
     checkLocalStateAsync(): Promise<void>;
-    get isAnonymousAuth(): boolean;
-    get isCustomAuth(): boolean;
-    get isWeixinAuth(): boolean;
-    get isUsernameAuth(): boolean;
-    get loginType(): string;
-    get isPhoneAuth(): boolean;
 }
 declare class Auth {
     private readonly _config;
     private readonly _cache;
-    private readonly _request;
-    private readonly _runtime;
-    private _anonymousAuthProvider;
-    private _customAuthProvider;
-    private _weixinAuthProvider;
-    private _emailAuthProvider;
-    private _usernameAuthProvider;
-    private _phoneAuthProvider;
-    private _oAuth2AuthProvider;
+    private _oauthInstance;
     constructor(config: ICloudbaseAuthConfig & {
         cache: ICloudbaseCache;
-        request: ICloudbaseRequest;
+        request?: ICloudbaseRequest;
         runtime?: string;
     });
+    bindPhoneNumber(params: authModels.BindPhoneRequest): Promise<void>;
+    unbindProvider(params: authModels.UnbindProviderRequest): Promise<void>;
+    bindEmail(params: authModels.BindEmailRequest): Promise<void>;
+    verify(params: authModels.VerifyRequest): Promise<authModels.VerifyResponse>;
+    getVerification(params: authModels.GetVerificationRequest): Promise<authModels.GetVerificationResponse>;
     get currentUser(): IUser;
-    get loginType(): LOGINTYPE;
-    getCurrenUser(): Promise<any>;
-    getLoginType(): Promise<LOGINTYPE>;
+    getCurrentUser(): Promise<IUser>;
+    signInAnonymously(): 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(): Promise<void>;
+    hasLoginState(): LoginState | null;
+    getLoginState(): Promise<LoginState>;
+    getUserInfo(): Promise<IUserInfo>;
+    bindWithProvider(params: authModels.BindWithProviderRequest): Promise<void>;
+    queryUser(queryObj: authModels.QueryUserProfileRequest): Promise<authModels.QueryUserProfileResponse>;
     getAccessToken(): Promise<{
         accessToken: string;
         env: string;
     }>;
-    weixinAuthProvider({ appid, scope, state }: {
-        appid: any;
-        scope: any;
-        state: any;
-    }): WeixinAuthProvider;
-    anonymousAuthProvider(): AnonymousAuthProvider;
-    customAuthProvider(): CustomAuthProvider;
-    emailAuthProvider(): EmailAuthProvider;
-    usernameAuthProvider(): UsernameAuthProvider;
-    phoneAuthProvider(): PhoneAuthProvider;
-    oAuth2AuthProvider(options?: IOAuth2AuthProviderOptions): OAuth2AuthProvider;
-    signWithOAuth2Popup(): void;
-    signInWithOAuth2Modal(elemId: string): void;
-    signInWithUsernameAndPassword(username: string, password: string): Promise<ILoginState>;
-    isUsernameRegistered(username: string): Promise<boolean>;
-    signInWithEmailAndPassword(email: string, password: string): Promise<ILoginState>;
-    signUpWithEmailAndPassword(email: string, password: string): Promise<any>;
-    sendPasswordResetEmail(email: string): Promise<any>;
-    signOut(): Promise<any>;
+    grantProviderToken(params: authModels.GrantProviderTokenRequest): Promise<authModels.GrantProviderTokenResponse>;
+    signInWithProvider(params: authModels.SignInWithProviderRequest): Promise<LoginState>;
+    grantToken(params: authModels.GrantTokenRequest): Promise<LoginState>;
+    genProviderRedirectUri(params: authModels.GenProviderRedirectUriRequest): Promise<authModels.GenProviderRedirectUriResponse>;
+    resetPassword(params: authModels.ResetPasswordRequest): Promise<void>;
+    deviceAuthorize(params: authModels.DeviceAuthorizeRequest): Promise<authModels.DeviceAuthorizeResponse>;
+    sudo(params: authModels.SudoRequest): Promise<authModels.SudoResponse>;
+    deleteMe(params: authModels.WithSudoRequest): Promise<authModels.UserProfile>;
+    getProviders(): Promise<authModels.UserProfileProvider>;
+    loginScope(): Promise<string>;
     onLoginStateChanged(callback: Function): Promise<void>;
-    onLoginStateExpired(callback: Function): void;
-    onAccessTokenRefreshed(callback: Function): void;
-    onAnonymousConverted(callback: Function): void;
-    onLoginTypeChanged(callback: Function): void;
-    hasLoginState(): ILoginState | null;
-    getLoginState(): Promise<any>;
-    shouldRefreshAccessToken(hook: any): void;
-    getUserInfo(): Promise<any>;
-    getAuthHeader(): {
-        'x-cloudbase-credentials': string;
-    };
-    getAuthHeaderAsync(): Promise<{
-        'x-cloudbase-credentials': string;
-    }>;
-    sendPhoneCode(phoneNumber: string): Promise<boolean>;
-    signUpWithPhoneCode(phoneNumber: string, phoneCode: string, password: string): Promise<ILoginState>;
-    signInWithPhoneCodeOrPassword(param: {
-        phoneNumber: string;
-        phoneCode?: string;
-        password?: string;
-        signMethod?: string;
-    }): Promise<ILoginState>;
-    forceResetPwdByPhoneCode(param: {
-        phoneNumber: string;
-        phoneCode: string;
-        password: string;
-    }): Promise<ILoginState>;
-    private _onLoginTypeChanged;
+    private createLoginState;
 }
-declare const EVENTS: {
-    LOGIN_STATE_CHANGED: string;
-    LOGIN_STATE_EXPIRED: string;
-    LOGIN_TYPE_CHANGED: string;
-    ANONYMOUS_CONVERTED: string;
-    ACCESS_TOKEN_REFRESHD: string;
-};
-export { UserInfo, Auth, AuthProvider, EVENTS, eventBus };
+export { UserInfo, Auth, };
 export declare function registerAuth(app: Pick<ICloudbase, 'registerComponent'>): void;
-declare type IProvider = new (...args: any[]) => any;
-export declare function registerProvider(name: string, provider: IProvider): void;