@cloudbase/js-sdk 3.8.2-beta.1 → 3.8.2

package/auth/dist/index.d.ts

@@ -1,2 +1,271 @@
-import { ICloudbase } from '@cloudbase/types';
-export declare const registerAuth: (app: ICloudbase) => void;
+import type { ICloudbase, ICloudbaseConfig } from '@cloudbase/js-sdk/types';
+import type { ICloudbaseCache } from '@cloudbase/js-sdk/types/cache';
+import type { ICloudbaseRequest } from '@cloudbase/js-sdk/types/request';
+import type { ICloudbaseAuthConfig, IUser, ILoginState } from '@cloudbase/js-sdk/types/auth';
+import type { AuthOptions, Credentials } from '@cloudbase/js-sdk/oauth';
+import { CloudbaseOAuth, AuthError, authModels } from '@cloudbase/js-sdk/oauth';
+import { CloudbaseEventEmitter } from './utilities';
+import { AuthV1Compat, WeixinAuthProvider, CustomAuthProvider, AnonymousAuthProvider } from './v1-compat';
+import { AuthOtpResponse, AuthResponse, CommonRes, DeleteMeReq, GetClaimsRes, GetUserIdentitiesRes, GetUserRes, LinkIdentityReq, LinkIdentityRes, OAuthResponse, OnAuthStateChangeCallback, ReauthenticateRes, ResendParams, ResendRes, ResetPasswordForEmailRes, ResetPasswordForOldReq, SetSessionReq, SignInAnonymouslyCredentials, SignInRes, SignInWithIdTokenReq, SignInWithOAuthCredentials, SignInWithPasswordCredentials, SignInWithPasswordlessCredentials, SignUpRes, UnlinkIdentityReq, UpdateUserWithVerificationRes, UserAttributes, UserResponse, VerifyOAuthReq, VerifyOAuthRes, VerifyOtpParams, GetAccessTokenRes } from './type';
+export type { AuthResponse, AuthTokenResponsePassword, AuthOtpResponse, UserResponse, OAuthResponse, SignInRes, GetUserRes, CommonRes, SignInWithOtpRes, SignInOAuthRes, GetClaimsRes, ResetPasswordForEmailRes, GetUserIdentitiesRes, LinkIdentityRes, ReauthenticateRes, ResendRes, UpdateUserWithVerificationRes, OnAuthStateChangeCallback, SignInWithPasswordCredentials, SignInWithPasswordlessCredentials, SignUpWithPasswordCredentials, SignInWithOAuthCredentials, SignInAnonymouslyCredentials, VerifyOtpParams, ResendParams, UserAttributes, SignInWithPasswordReq, SignInWithIdTokenReq, SignInWithOAuthReq, VerifyOAuthReq, VerifyOtpReq, LinkIdentityReq, UnlinkIdentityReq, UpdateUserReq, SignInWithOtpReq, ResetPasswordForOldReq, ResendReq, SetSessionReq, DeleteMeReq, SignUpRes, GetAccessTokenRes, AuthResult, } 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;
+    eventBus: CloudbaseEventEmitter;
+    runtime?: string;
+}
+declare class Auth extends AuthV1Compat {
+    readonly config: IAuthConfig;
+    oauthInstance: CloudbaseOAuth;
+    readonly cache: ICloudbaseCache;
+    private listeners;
+    private hasListenerSetUp;
+    constructor(config: IAuthConfig);
+    signInAnonymously(params: SignInAnonymouslyCredentials): Promise<AuthResponse>;
+    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: SignInWithPasswordCredentials): Promise<AuthResponse>;
+    signInWithIdToken(params: SignInWithIdTokenReq): Promise<SignInRes>;
+    signInWithOtp(params: SignInWithPasswordlessCredentials): Promise<AuthOtpResponse>;
+    verifyOAuth(params?: VerifyOAuthReq): Promise<VerifyOAuthRes>;
+    signInWithOAuth(params: SignInWithOAuthCredentials): Promise<OAuthResponse>;
+    getClaims(): Promise<GetClaimsRes>;
+    resetPasswordForEmail(emailOrPhone: string, options?: {
+        redirectTo?: string;
+    }): Promise<ResetPasswordForEmailRes>;
+    resetPasswordForOld(params: ResetPasswordForOldReq): Promise<SignInRes>;
+    verifyOtp(params: VerifyOtpParams): Promise<AuthResponse>;
+    getSession(): Promise<SignInRes>;
+    refreshSession(refresh_token?: string): Promise<SignInRes>;
+    getUser(isRefresh?: boolean): Promise<GetUserRes>;
+    refreshUser(): Promise<CommonRes>;
+    updateUser(params: UserAttributes): Promise<UserResponse | UpdateUserWithVerificationRes>;
+    getUserIdentities(): Promise<GetUserIdentitiesRes>;
+    linkIdentity(params: LinkIdentityReq): Promise<LinkIdentityRes>;
+    unlinkIdentity(params: UnlinkIdentityReq): Promise<CommonRes>;
+    reauthenticate(): Promise<ReauthenticateRes>;
+    resend(params: ResendParams): 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 | null>;
+    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<GetAccessTokenRes>;
+    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/js-sdk/oauth';
+export declare function registerAuth(app: Pick<ICloudbase, 'registerComponent'>): void;

package/auth/dist/type.d.ts

@@ -0,0 +1,295 @@
+import type { authModels, OAUTH_TYPE } from '@cloudbase/js-sdk/oauth';
+import { AuthError, AuthErrorCategory, AuthErrorCode } from '@cloudbase/js-sdk/oauth';
+export { AuthErrorCategory, AuthErrorCode };
+export type AuthResult<D extends object> = {
+    data: D;
+    error: null;
+} | {
+    data: {
+        [K in keyof D]: null;
+    };
+    error: AuthError;
+};
+export interface SignInAnonymouslyCredentials {
+    provider_token?: string;
+}
+export type SignInAnonymouslyReq = SignInAnonymouslyCredentials;
+export declare type User = {
+    id: any;
+    aud: string;
+    role: string[];
+    email: any;
+    email_confirmed_at: string;
+    phone: any;
+    phone_confirmed_at: string;
+    confirmed_at: string;
+    last_sign_in_at: string;
+    app_metadata: {
+        provider: any;
+        providers: any[];
+    };
+    user_metadata: {
+        name: any;
+        picture: any;
+        username: any;
+        gender: any;
+        locale: any;
+        uid: any;
+        nickName: any;
+        avatarUrl: any;
+        location: any;
+        hasPassword: any;
+    };
+    identities: any;
+    created_at: string;
+    updated_at: string;
+    is_anonymous: boolean;
+};
+export declare type Session = {
+    access_token?: string;
+    refresh_token?: string;
+    expires_in?: number;
+    token_type?: string;
+    user: User;
+};
+export type SignInWithPasswordCredentials = PasswordCredentialsBase & {
+    is_encrypt?: boolean;
+    options?: {
+        is_encrypt?: boolean;
+        captchaToken?: string;
+    };
+};
+export type PasswordCredentialsBase = {
+    email: string;
+    password: string;
+} | {
+    phone: string;
+    password: string;
+} | {
+    username: string;
+    password: string;
+};
+export type SignInWithPasswordReq = SignInWithPasswordCredentials;
+export type CommonRes = AuthResult<{}>;
+export type SignInRes = AuthResult<{
+    user?: User | null;
+    session?: Session | null;
+}>;
+export type AuthResponse = SignInRes;
+export type AuthTokenResponsePassword = SignInRes;
+export type GetUserRes = AuthResult<{
+    user?: User | null;
+}>;
+export type UserResponse = GetUserRes;
+export interface UpdateUserVerifyOtpParams {
+    email?: string;
+    phone?: string;
+    token: string | number;
+}
+declare type UpdateUserVerifyCallback = (params: UpdateUserVerifyOtpParams) => Promise<GetUserRes>;
+export type UpdateUserWithVerificationRes = AuthResult<{
+    verifyOtp?: UpdateUserVerifyCallback;
+    messageId?: string;
+}>;
+export interface SignInWithIdTokenReq {
+    provider?: string;
+    token: string;
+}
+export interface SignInWithOAuthCredentials {
+    provider: string;
+    options?: {
+        redirectTo?: string;
+        skipBrowserRedirect?: boolean;
+        state?: string;
+        queryParams?: Record<string, string>;
+        type?: (typeof OAUTH_TYPE)[keyof typeof OAUTH_TYPE];
+    };
+}
+export type SignInWithOAuthReq = SignInWithOAuthCredentials;
+export type SignInOAuthRes = AuthResult<{
+    url?: string | null;
+    provider?: string | null;
+    scopes?: string;
+}>;
+export type OAuthResponse = SignInOAuthRes;
+export type GetClaimsRes = AuthResult<{
+    claims?: {
+        iss: string;
+        sub: string;
+        aud: string;
+        exp: number;
+        iat: number;
+        at_hash: string;
+        name: string;
+        picture?: string;
+        email?: string;
+        phone_number?: string;
+        scope: string;
+        project_id: string;
+        provider?: string;
+        provider_type?: string;
+        groups?: string[];
+        meta?: {
+            wxOpenId?: string;
+            wxUnionId?: string;
+        };
+        user_id: string;
+        roles: string[];
+        user_type: string;
+        client_type: string;
+        is_system_admin: boolean;
+    };
+    header?: {
+        alg: string;
+        kid: string;
+    };
+    signature?: string | null;
+}>;
+export interface UserAttributes extends authModels.ModifyUserBasicInfoRequest {
+    email?: string;
+    phone?: string;
+    username?: string;
+    description?: string;
+    avatar_url?: string;
+    nickname?: string;
+    gender?: 'MALE' | 'FEMALE';
+    password?: never;
+    new_password?: never;
+}
+export type UpdateUserReq = UserAttributes;
+export type GetUserIdentitiesRes = AuthResult<{
+    identities?: Array<{
+        id: string;
+        name: string;
+        picture: string;
+    }> | null;
+}>;
+export interface LinkIdentityReq {
+    provider: string;
+}
+export interface UnlinkIdentityReq {
+    provider: string;
+}
+export type LinkIdentityRes = AuthResult<{
+    provider?: string | null;
+    type?: (typeof OAUTH_TYPE)[keyof typeof OAUTH_TYPE];
+}>;
+export declare type OnAuthStateChangeEvent = 'SIGNED_OUT' | 'SIGNED_IN' | 'INITIAL_SESSION' | 'PASSWORD_RECOVERY' | 'TOKEN_REFRESHED' | 'USER_UPDATED' | 'BIND_IDENTITY';
+export declare type OnAuthStateChangeCallback = (event: OnAuthStateChangeEvent, session: Session, info?: Record<string, any>) => void;
+export type MobileOtpType = 'sms' | 'phone_change' | (string & {});
+export type EmailOtpType = 'signup' | 'invite' | 'magiclink' | 'recovery' | 'email_change' | 'email' | (string & {});
+export interface VerifyMobileOtpParams {
+    phone: string;
+    token: string | number;
+    type?: MobileOtpType | EmailOtpType;
+    messageId?: string;
+}
+export interface VerifyEmailOtpParams {
+    email: string;
+    token: string | number;
+    type?: MobileOtpType | EmailOtpType;
+    messageId?: string;
+}
+export type VerifyOtpParams = VerifyMobileOtpParams | VerifyEmailOtpParams;
+export type VerifyOtpReq = VerifyOtpParams;
+export type SignInWithPasswordlessCredentials = {
+    email: string;
+    options?: {
+        shouldCreateUser?: boolean;
+        emailRedirectTo?: string;
+        captchaToken?: string;
+    };
+} | {
+    phone: string;
+    options?: {
+        shouldCreateUser?: boolean;
+        captchaToken?: string;
+    };
+};
+export type SignInWithOtpReq = SignInWithPasswordlessCredentials;
+export interface VerifyOtpCallbackParams {
+    token: string | number;
+    messageId?: string;
+}
+declare type OtpCallback = (params: VerifyOtpCallbackParams) => Promise<SignInRes>;
+export type SignInWithOtpRes = AuthResult<{
+    user?: User | null;
+    session?: Session | null;
+    verifyOtp?: OtpCallback;
+}>;
+export type AuthOtpResponse = SignInWithOtpRes;
+export type SignUpRes = AuthResult<{
+    user?: User;
+    session?: Session;
+    verifyOtp?: OtpCallback;
+}>;
+export type SignUpWithPasswordCredentials = {
+    email: string;
+    password?: string;
+    options?: {
+        data?: Record<string, any>;
+        emailRedirectTo?: string;
+        captchaToken?: string;
+    };
+} | {
+    phone: string;
+    password?: string;
+    options?: {
+        data?: Record<string, any>;
+        channel?: 'sms' | 'whatsapp';
+        captchaToken?: string;
+    };
+};
+export interface ResendParamsBase {
+    type: 'signup' | 'email_change' | 'phone_change' | 'sms';
+}
+export type ResendParams = {
+    type?: 'signup' | 'email_change';
+    email: string;
+    phone?: never;
+} | {
+    type?: 'sms' | 'phone_change';
+    phone: string;
+    email?: never;
+};
+export type ResendReq = ResendParams;
+export type ResendRes = AuthResult<{
+    messageId?: string | null;
+}>;
+export interface GetAccessTokenRes {
+    accessToken: string;
+    env: string;
+}
+export interface VerifyOAuthReq {
+    code?: string;
+    state?: string;
+    provider?: string;
+}
+export interface UpdateUserAttributes {
+    nonce: string;
+    password: string;
+}
+export type ResetPasswordForEmailRes = AuthResult<{
+    updateUser?: ((attributes: UpdateUserAttributes) => Promise<SignInRes>) | null;
+}>;
+export type ReauthenticateRes = AuthResult<{
+    updateUser?: ((attributes: UpdateUserAttributes) => Promise<SignInRes>) | null;
+}>;
+export interface SetSessionReq {
+    access_token: string;
+    refresh_token: string;
+}
+export interface DeleteMeReq {
+    password: string;
+}
+export interface ResetPasswordForOldReq {
+    old_password: string;
+    new_password: string;
+}
+export type VerifyOAuthRes = AuthResult<{
+    user?: User;
+    session?: Session;
+    redirectUrl?: string;
+    provider?: string;
+    type?: (typeof OAUTH_TYPE)[keyof typeof OAUTH_TYPE];
+}>;

package/auth/dist/utilities.d.ts

@@ -0,0 +1,7 @@
+export { printWarn, throwError } from '@cloudbase/js-sdk/utilities/dist/cjs/libs/util';
+export { ERRORS, COMMUNITY_SITE_URL } from '@cloudbase/js-sdk/utilities/dist/cjs/constants/index';
+export { catchErrorsDecorator } from '@cloudbase/js-sdk/utilities/dist/cjs/helpers/index';
+export { CloudbaseEventEmitter } from '@cloudbase/js-sdk/utilities/dist/cjs/libs/events';
+export { CloudbaseCache } from '@cloudbase/js-sdk/utilities/dist/cjs/libs/cache';
+export { default as adapterForWxMp } from '@cloudbase/adapter-wx_mp';
+export { useDefaultAdapter } from '@cloudbase/js-sdk/utilities/dist/cjs/adapters/index';

package/auth/dist/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function saveToBrowserSession(key: string, value: Record<string, any>): void;
+export declare function getBrowserSession(key: string): any;
+export declare function removeBrowserSession(key: string): boolean;
+export declare function addUrlSearch(search: Location['search'], hash?: Location['hash']): string;
+export declare function removeUrlParams(params: string[]): void;

package/auth/dist/v1-compat.d.ts

@@ -0,0 +1,77 @@
+import type { authModels } from '@cloudbase/js-sdk/oauth';
+import type { SignUpRes } from './type';
+export declare class WeixinAuthProvider {
+    constructor(_options: {
+        authInstance: any;
+        appid: string;
+        scope: string;
+    });
+    signInWithRedirect(): void;
+    getRedirectResult(_options?: {
+        createUser?: boolean;
+        syncUserInfo?: boolean;
+    }): Promise<any>;
+    getLinkRedirectResult(_options?: {
+        withUnionId?: boolean;
+    }): Promise<void>;
+}
+export declare class CustomAuthProvider {
+    private authInstance;
+    constructor(options: {
+        authInstance: any;
+    });
+    signIn(ticket: string): Promise<void>;
+}
+export declare class AnonymousAuthProvider {
+    private authInstance;
+    constructor(options: {
+        authInstance: any;
+    });
+    signIn(): Promise<void>;
+}
+export declare abstract class AuthV1Compat {
+    abstract readonly config: any;
+    weixinAuthProvider(options: {
+        appid: string;
+        scope: string;
+    }): WeixinAuthProvider;
+    customAuthProvider(): CustomAuthProvider;
+    anonymousAuthProvider(): AnonymousAuthProvider;
+    signUpWithEmailAndPassword(email: string, password: string): Promise<SignUpRes>;
+    signInWithEmailAndPassword(email: string, password: string): Promise<any>;
+    sendPasswordResetEmail(email: string): Promise<void>;
+    signInWithUsernameAndPassword(username: string, password: string): Promise<any>;
+    sendPhoneCode(phoneNumber: string): Promise<boolean>;
+    signUpWithPhoneCode(phoneNumber: string, phoneCode: string, password?: string): Promise<any>;
+    signInWithPhoneCodeOrPassword(params: {
+        phoneNumber: string;
+        phoneCode?: string;
+        password?: string;
+    }): Promise<any>;
+    forceResetPwdByPhoneCode(params: {
+        phoneNumber: string;
+        phoneCode: string;
+        password: string;
+    }): Promise<any>;
+    shouldRefreshAccessToken(_callback: () => boolean): void;
+    onLoginStateExpired(callback: Function): void;
+    onAccessTokenRefreshed(callback: Function): void;
+    onAnonymousConverted(callback: Function): void;
+    onLoginTypeChanged(callback: Function): void;
+    abstract signIn(params: authModels.SignInRequest): Promise<any>;
+    abstract signUp(params: authModels.SignUpRequest & {
+        phone?: string;
+    }): Promise<SignUpRes>;
+    abstract signInWithCustomTicket(getTickFn?: authModels.GetCustomSignTicketFn): Promise<any>;
+    abstract signInAnonymously(params: any): Promise<any>;
+    abstract getVerification(params: any, options?: any): Promise<authModels.GetVerificationResponse>;
+    abstract resetPassword(params: authModels.ResetPasswordRequest): Promise<void>;
+    abstract onLoginStateChanged(callback: Function): Promise<void>;
+    abstract onAuthStateChange(callback: any): any;
+    abstract createLoginState(params?: any, options?: any): Promise<any>;
+    abstract signInWithOAuth(params: any): Promise<any>;
+    abstract grantProviderToken(params: authModels.GrantProviderTokenRequest): Promise<authModels.GrantProviderTokenResponse>;
+    abstract bindWithProvider(params: authModels.BindWithProviderRequest): Promise<void>;
+    protected abstract formatPhone(phone: string): string;
+}
+export declare function applyUserV1Compat(UserClass: any): void;

package/cloudrun/dist/index.d.ts

@@ -1 +1,4 @@
-export * from '@cloudbase/cloudrun';
+import { ICloudbase } from '@cloudbase/js-sdk/types';
+import { ICallFunctionOptions, ICustomReqOpts } from '@cloudbase/js-sdk/types/functions';
+export declare function requestContainer(this: any, options: ICallFunctionOptions, customReqOpts?: ICustomReqOpts): Promise<any>;
+export declare function registerCloudrun(app: Pick<ICloudbase, 'registerComponent'>): void;

package/container/dist/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const COMPONENT_NAME = "container";

package/container/dist/go_wams_exec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/container/dist/index.d.ts

@@ -1,2 +1,13 @@
-import { ICloudbase } from '@cloudbase/types';
-export declare const registerContainers: (app: ICloudbase) => void;
+import { ICloudbase } from '@cloudbase/js-sdk/types';
+import { ICallContainerOptions, IContianerConfig } from '@cloudbase/js-sdk/types/container';
+export declare let t: (str: any) => any;
+export declare class CloudbaseContainers {
+    private readonly config;
+    private wasm;
+    private containerInitPromise;
+    private defaultHeaders;
+    constructor(config: IContianerConfig);
+    callContainer(options: ICallContainerOptions, callback?: Function): Promise<any>;
+    initContainer(config: Omit<IContianerConfig, 'wasmUrl' | 'jsUrl'>): Promise<any>;
+}
+export declare function registerContainers(app: Pick<ICloudbase, 'registerComponent'>): void;