@cloudbase/js-sdk 3.6.2 → 3.6.3

package/miniprogram_dist/auth/index.d.ts

@@ -0,0 +1,284 @@
+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, ILoginState } from '@cloudbase/types/auth';
+import type { AuthOptions, Credentials } from '@cloudbase/oauth';
+import { CloudbaseOAuth, AuthError, authModels } from '@cloudbase/oauth';
+import { AuthV1Compat, WeixinAuthProvider, CustomAuthProvider, AnonymousAuthProvider } from './v1-compat';
+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, VerifyOAuthRes, 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;
+    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;
+}
+interface IUserOptions {
+    cache: ICloudbaseCache;
+    oauthInstance: CloudbaseOAuth;
+}
+export declare class User implements IUser {
+    uid?: string;
+    gender?: string;
+    picture?: string;
+    email?: string;
+    emailVerified?: boolean;
+    phoneNumber?: string;
+    username?: string;
+    name?: string;
+    providers?: {
+        id?: string;
+        providerUserId?: string;
+        name?: string;
+    }[];
+    birthdate?: string;
+    zoneinfo?: string;
+    locale?: string;
+    sub?: string;
+    createdFrom?: string;
+    open_id?: string;
+    private cache;
+    private oauthInstance;
+    constructor(options: IUserOptions);
+    checkLocalInfo(): Promise<void>;
+    checkLocalInfoAsync(): Promise<void>;
+    update(userInfo: authModels.UserProfile): Promise<void>;
+    updateUserBasicInfo(params: authModels.ModifyUserBasicInfoRequest): Promise<void>;
+    updatePassword(newPassword: string, oldPassword: string): Promise<void>;
+    updateUsername(username: string): Promise<void>;
+    refresh(params?: {
+        version?: string;
+        query?: any;
+    }): Promise<authModels.UserInfo>;
+    getLocalUserInfo(key?: string): string | boolean | Record<string, any>;
+    setLocalUserInfo(userInfo: any): void;
+    private getLocalUserInfoAsync;
+    private setUserInfo;
+}
+interface ILoginStateOptions extends IUserOptions {
+    envId: string;
+}
+export declare class LoginState implements ILoginState {
+    user: User;
+    oauthLoginState: any;
+    private oauthInstance;
+    private cache;
+    constructor(options: ILoginStateOptions);
+    checkLocalState(): void;
+    checkLocalStateAsync(): Promise<void>;
+}
+interface IAuthConfig extends ICloudbaseAuthConfig {
+    cache: ICloudbaseCache;
+    request?: ICloudbaseRequest;
+    runtime?: string;
+}
+declare class Auth extends AuthV1Compat {
+    readonly config: IAuthConfig;
+    oauthInstance: CloudbaseOAuth;
+    readonly cache: ICloudbaseCache;
+    private listeners;
+    private hasListenerSetUp;
+    constructor(config: IAuthConfig);
+    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<VerifyOAuthRes>;
+    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: any;
+            session: any;
+        };
+        error: AuthError;
+    }>;
+    verifyOtp(params: VerifyOtpReq): Promise<SignInRes>;
+    getSession(): Promise<SignInRes>;
+    refreshSession(refresh_token?: string): Promise<SignInRes>;
+    getUser(isRefresh?: boolean): 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, useWxCloud }: {
+        phoneCode?: string;
+        useWxCloud?: boolean;
+    }): Promise<SignInRes>;
+    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, options?: {
+        withCaptcha: boolean;
+    }): Promise<authModels.GetVerificationResponse>;
+    get currentUser(): User;
+    getCurrentUser(isRefresh?: boolean): Promise<(authModels.UserInfo & Partial<User>) | null>;
+    signInAnonymouslyInWx({ useWxCloud, }?: {
+        useWxCloud?: boolean;
+    }): Promise<LoginState>;
+    bindOpenId(): Promise<void>;
+    signInWithUnionId(): Promise<LoginState>;
+    signInWithSms({ verificationInfo, verificationCode, phoneNum, bindInfo, }: {
+        verificationInfo?: {
+            verification_id: string;
+            is_user: boolean;
+        };
+        verificationCode?: string;
+        phoneNum?: string;
+        bindInfo?: any;
+    }): Promise<LoginState>;
+    signInWithEmail({ verificationInfo, verificationCode, bindInfo, email, }: {
+        verificationInfo?: {
+            verification_id: string;
+            is_user: boolean;
+        };
+        verificationCode?: string;
+        bindInfo?: any;
+        email?: string;
+    }): Promise<LoginState>;
+    setCustomSignFunc(getTickFn: authModels.GetCustomSignTicketFn): void;
+    signIn(params: authModels.SignInRequest): Promise<LoginState>;
+    setPassword(params: authModels.SetPasswordRequest): Promise<void>;
+    isUsernameRegistered(username: string): Promise<boolean>;
+    hasLoginState(): LoginState | null;
+    getLoginState(): Promise<LoginState>;
+    getUserInfo(): Promise<(authModels.UserInfo & Partial<User>) | null>;
+    getWedaUserInfo(): Promise<any>;
+    updateUserBasicInfo(params: authModels.ModifyUserBasicInfoRequest): Promise<void>;
+    getAuthHeader(): {};
+    bindWithProvider(params: authModels.BindWithProviderRequest): Promise<void>;
+    queryUser(queryObj: authModels.QueryUserProfileRequest): Promise<authModels.QueryUserProfileResponse>;
+    getAccessToken(): Promise<{
+        accessToken: string;
+        env: string;
+    }>;
+    grantProviderToken(params: authModels.GrantProviderTokenRequest): Promise<authModels.GrantProviderTokenResponse>;
+    patchProviderToken(params: authModels.PatchProviderTokenRequest): Promise<authModels.PatchProviderTokenResponse>;
+    signInWithProvider(params: authModels.SignInWithProviderRequest): Promise<LoginState>;
+    signInWithWechat(params?: any): 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.ProvidersResponse>;
+    loginScope(): Promise<string>;
+    loginGroups(): Promise<string[]>;
+    onLoginStateChanged(callback: Function): Promise<void>;
+    refreshTokenForce(params: {
+        version?: string;
+    }): Promise<Credentials>;
+    getCredentials(): Promise<Credentials>;
+    setCredentials(credentials: Credentials): Promise<void>;
+    getProviderSubType(): Promise<authModels.ProviderSubType>;
+    createCaptchaData(params: {
+        state: string;
+        redirect_uri?: string;
+    }): Promise<{
+        token: string;
+        data: string;
+    }>;
+    verifyCaptchaData(params: {
+        token: string;
+        key: string;
+    }): Promise<{
+        captcha_token: string;
+        expires_in: number;
+    }>;
+    getMiniProgramQrCode(params: authModels.GetMiniProgramQrCodeRequest): Promise<authModels.GetMiniProgramQrCodeResponse>;
+    getMiniProgramQrCodeStatus(params: authModels.GetMiniProgramQrCodeStatusRequest): Promise<authModels.GetMiniProgramQrCodeStatusResponse>;
+    modifyPassword(params: authModels.ModifyUserBasicInfoRequest): Promise<void>;
+    modifyPasswordWithoutLogin(params: authModels.ModifyPasswordWithoutLoginRequest): Promise<void>;
+    getUserBehaviorLog(params: authModels.GetUserBehaviorLog): Promise<authModels.GetUserBehaviorLogRes>;
+    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>;
+    protected formatPhone(phone: string): string;
+    private notifyListeners;
+    private setupListeners;
+    private convertToUser;
+    private validateParams;
+    private validateAtLeastOne;
+    private init;
+}
+type TInitAuthOptions = Pick<ICloudbaseAuthConfig, 'region' | 'persistence' | 'i18n' | 'accessKey' | 'useWxCloud' | 'auth'> & Partial<AuthOptions> & {
+    detectSessionInUrl?: boolean;
+};
+export declare function generateAuthInstance(config: TInitAuthOptions & {
+    sdkVersion?: string;
+}, options?: {
+    clientId: ICloudbaseConfig['clientId'];
+    env: ICloudbaseConfig['env'];
+    apiOrigin?: string;
+    getApiOrigin?: () => string;
+    cache?: ICloudbaseCache;
+    platform?: ICloudbase['platform'];
+    app?: ICloudbase;
+    debug?: ICloudbaseAuthConfig['debug'];
+    detectSessionInUrl?: ICloudbaseAuthConfig['detectSessionInUrl'];
+}): {
+    authInstance: Auth;
+    oauthInstance: CloudbaseOAuth;
+};
+export { UserInfo, Auth, WeixinAuthProvider, CustomAuthProvider, AnonymousAuthProvider };
+export { AuthErrorCategory, AuthErrorCode, AuthError } from '@cloudbase/oauth';
+export declare function registerAuth(app: Pick<ICloudbase, 'registerComponent'>): void;