@cloudbase/js-sdk 3.3.14-beta.3 → 3.3.14-beta.5

package/node_modules/@cloudbase/oauth/dist/esm/auth/apis.js

@@ -0,0 +1,768 @@
+'use strict';
+import { ApiUrls, ApiUrlsV2, AUTH_STATE_CHANGED_TYPE, ErrorType, EVENTS, OAUTH_TYPE } from './consts';
+import { OAuth2Client, defaultStorage } from '../oauth2client/oauth2client';
+import { Captcha } from '../captcha/captcha';
+import { deepClone } from '../utils';
+import MyURLSearchParams from '../utils/urlSearchParams';
+import { AuthError } from './auth-error';
+async function getEncryptUtils(isEncrypt, adapter) {
+    const getUtils = async () => {
+        try {
+            const utils = require('../utils/encrypt');
+            return utils;
+        }
+        catch (error) {
+            try {
+                const utils = await import('../utils/encrypt');
+                return utils;
+            }
+            catch (error) {
+                return;
+            }
+        }
+    };
+    try {
+        if ((adapter?.root?.globalThis || globalThis).IS_MP_BUILD) {
+            return;
+        }
+        if (!process.env.IS_MP_BUILD && isEncrypt) {
+            return getUtils();
+        }
+    }
+    catch (error) {
+        if (isEncrypt) {
+            return getUtils();
+        }
+    }
+}
+export class Auth {
+    static parseParamsToSearch(params) {
+        Object.keys(params).forEach((key) => {
+            if (!params[key]) {
+                delete params[key];
+            }
+        });
+        const searchParams = new MyURLSearchParams(params);
+        return searchParams.toString();
+    }
+    constructor(opts) {
+        let { request } = opts;
+        let oAuth2Client = opts.credentialsClient;
+        if (!oAuth2Client) {
+            const initOptions = {
+                apiOrigin: opts.apiOrigin,
+                apiPath: opts.apiPath,
+                clientId: opts.clientId,
+                storage: opts.storage,
+                env: opts.env,
+                baseRequest: opts.baseRequest,
+                anonymousSignInFunc: opts.anonymousSignInFunc,
+                wxCloud: opts.wxCloud,
+                onCredentialsError: opts.onCredentialsError,
+                headers: opts.headers || {},
+                i18n: opts.i18n,
+                debug: opts.debug,
+            };
+            oAuth2Client = new OAuth2Client(initOptions);
+        }
+        if (!request) {
+            const baseRequest = oAuth2Client.request.bind(oAuth2Client);
+            const captcha = new Captcha({
+                env: opts.env,
+                clientId: opts.clientId,
+                request: baseRequest,
+                storage: opts.storage,
+                adapter: opts.adapter,
+                oauthInstance: this,
+                ...opts.captchaOptions,
+            });
+            request = captcha.request.bind(captcha);
+        }
+        this.config = {
+            env: opts.env,
+            apiOrigin: opts.apiOrigin,
+            apiPath: opts.apiPath,
+            clientId: opts.clientId,
+            request,
+            credentialsClient: oAuth2Client,
+            storage: opts.storage || defaultStorage,
+            adapter: opts.adapter,
+        };
+    }
+    getParamsByVersion(params, key) {
+        const paramsTemp = deepClone(params);
+        const url = { v2: ApiUrlsV2 }[paramsTemp?.version]?.[key] || ApiUrls[key];
+        if (paramsTemp) {
+            delete paramsTemp.version;
+        }
+        return { params: paramsTemp, url };
+    }
+    async signIn(params) {
+        const version = params.version || 'v1';
+        const res = this.getParamsByVersion(params, 'AUTH_SIGN_IN_URL');
+        if (res.params.query) {
+            delete res.params.query;
+        }
+        const body = await this.getEncryptParams(res.params);
+        const credentials = await this.config.request(res.url, {
+            method: 'POST',
+            body,
+        });
+        await this.config.credentialsClient.setCredentials({
+            ...credentials,
+            version,
+        });
+        return Promise.resolve(credentials);
+    }
+    async signInAnonymously(data = {}, useWxCloud = false) {
+        const credentials = await this.config.request(ApiUrls.AUTH_SIGN_IN_ANONYMOUSLY_URL, {
+            method: 'POST',
+            body: data,
+            useWxCloud,
+        });
+        await this.config.credentialsClient.setCredentials(credentials);
+        return Promise.resolve(credentials);
+    }
+    async signUp(params) {
+        const data = await this.config.request(ApiUrls.AUTH_SIGN_UP_URL, {
+            method: 'POST',
+            body: params,
+        });
+        await this.config.credentialsClient.setCredentials(data);
+        return Promise.resolve(data);
+    }
+    async signOut(params) {
+        let resp = {};
+        if (params) {
+            try {
+                resp = await this.config.request(ApiUrls.AUTH_SIGNOUT_URL, {
+                    method: 'POST',
+                    withCredentials: true,
+                    body: params,
+                });
+            }
+            catch (err) {
+                if (err.error !== ErrorType.UNAUTHENTICATED) {
+                    console.log('sign_out_error', err);
+                }
+            }
+            await this.config.credentialsClient.setCredentials();
+            return resp;
+        }
+        const accessToken = await this.config.credentialsClient.getAccessToken();
+        const data = await this.config.request(ApiUrls.AUTH_REVOKE_URL, {
+            method: 'POST',
+            body: {
+                token: accessToken,
+            },
+        });
+        await this.config.credentialsClient.setCredentials();
+        return Promise.resolve(data);
+    }
+    async revokeAllDevices() {
+        await this.config.request(ApiUrls.AUTH_REVOKE_ALL_URL, {
+            method: 'DELETE',
+            withCredentials: true,
+        });
+    }
+    async revokeDevice(params) {
+        await this.config.request(ApiUrls.AUTHORIZED_DEVICES_DELETE_URL + params.device_id, {
+            method: 'DELETE',
+            withCredentials: true,
+        });
+    }
+    async getVerification(params, options) {
+        let withCredentials = false;
+        if (params.target === 'CUR_USER') {
+            withCredentials = true;
+        }
+        else {
+            const hasLogin = await this.hasLoginState();
+            if (hasLogin) {
+                withCredentials = true;
+            }
+        }
+        const body = deepClone(params);
+        if (body.phone_number && !/^\+\d{1,3}\s+\d+/.test(body.phone_number)) {
+            body.phone_number = `+86 ${body.phone_number}`;
+        }
+        return this.config.request(ApiUrls.VERIFICATION_URL, {
+            method: 'POST',
+            body,
+            withCaptcha: options?.withCaptcha || false,
+            withCredentials,
+        });
+    }
+    async verify(params) {
+        const res = this.getParamsByVersion(params, 'VERIFY_URL');
+        const data = await this.config.request(res.url, {
+            method: 'POST',
+            body: res.params,
+        });
+        if (params?.version === 'v2') {
+            await this.config.credentialsClient.setCredentials({
+                ...data,
+                version: 'v2',
+            });
+        }
+        return data;
+    }
+    async genProviderRedirectUri(params) {
+        const { provider_redirect_uri: redirect_uri, other_params: otherParams = {}, ...restParams } = params;
+        if (redirect_uri && !restParams.redirect_uri) {
+            restParams.redirect_uri = redirect_uri;
+        }
+        let url = `${ApiUrls.PROVIDER_URI_URL}?${Auth.parseParamsToSearch(restParams)}`;
+        Object.keys(otherParams).forEach((key) => {
+            const value = otherParams[key];
+            if (key === 'sign_out_uri' && !(value?.length > 0)) {
+                return;
+            }
+            url += `&other_params[${key}]=${encodeURIComponent(value)}`;
+        });
+        return this.config.request(url, {
+            method: 'GET',
+        });
+    }
+    async grantProviderToken(params, useWxCloud = false) {
+        return this.config.request(ApiUrls.PROVIDER_TOKEN_URL, {
+            method: 'POST',
+            body: params,
+            useWxCloud,
+        });
+    }
+    async patchProviderToken(params) {
+        return this.config.request(ApiUrls.PROVIDER_TOKEN_URL, {
+            method: 'PATCH',
+            body: params,
+        });
+    }
+    async signInWithProvider(params, useWxCloud = false) {
+        const res = this.getParamsByVersion(params, 'AUTH_SIGN_IN_WITH_PROVIDER_URL');
+        const credentials = await this.config.request(res.url, {
+            method: 'POST',
+            body: res.params,
+            useWxCloud,
+        });
+        await this.config.credentialsClient.setCredentials({
+            ...credentials,
+            version: params?.version || 'v1',
+        });
+        return Promise.resolve(credentials);
+    }
+    async toBindIdentity(params) {
+        const credentials = params.credentials || (await this.config.credentialsClient.localCredentials.getCredentials());
+        let res;
+        try {
+            await this.bindWithProvider({
+                provider_token: params.provider_token,
+            }, credentials);
+            res = { data: { type: OAUTH_TYPE.BIND_IDENTITY, provider: params.provider }, error: null };
+        }
+        catch (error) {
+            res = { data: { type: OAUTH_TYPE.BIND_IDENTITY }, error: new AuthError(error) };
+        }
+        if (params.fireEvent) {
+            this.config.eventBus?.fire?.(EVENTS.AUTH_STATE_CHANGED, {
+                event: AUTH_STATE_CHANGED_TYPE.BIND_IDENTITY,
+                info: res,
+            });
+        }
+        return res;
+    }
+    async getInitialSession() {
+        let data = {};
+        try {
+            if (typeof window === 'undefined' || typeof document === 'undefined') {
+                return { data: null, error: null };
+            }
+            const localSearch = new URLSearchParams(location?.search);
+            const code = localSearch.get('code');
+            const state = localSearch.get('state');
+            if (!code || !state) {
+                return { data: null, error: null };
+            }
+            let cacheData = null;
+            try {
+                cacheData = JSON.parse(sessionStorage.getItem(state) || 'null');
+            }
+            catch {
+            }
+            data = { type: cacheData?.type };
+            const errorParam = localSearch.get('error');
+            const errorDescription = localSearch.get('error_description');
+            if (errorParam || errorDescription) {
+                return {
+                    data,
+                    error: new AuthError({ message: errorDescription || errorParam || 'Unknown error from OAuth provider' }),
+                };
+            }
+            const provider = cacheData?.provider || localSearch.get('provider');
+            if (!provider) {
+                return { data, error: new AuthError({ message: 'Provider is required for OAuth verification' }) };
+            }
+            const redirectUri = location.origin + location.pathname;
+            const { provider_token: providerToken } = await this.grantProviderToken({
+                provider_id: provider,
+                provider_redirect_uri: redirectUri,
+                provider_code: code,
+            });
+            let credentials;
+            let user = null;
+            let res;
+            if (cacheData.type === OAUTH_TYPE.BIND_IDENTITY) {
+                credentials = await this.config.credentialsClient.localCredentials.getCredentials();
+                res = await this.toBindIdentity({ provider, provider_token: providerToken, credentials });
+            }
+            else if (cacheData.type === OAUTH_TYPE.SIGN_IN) {
+                res = this.getParamsByVersion({ provider }, 'AUTH_SIGN_IN_WITH_PROVIDER_URL');
+                credentials = await this.config.request(res.url, {
+                    method: 'POST',
+                    body: { provider_token: providerToken },
+                });
+                try {
+                    user = await this.getUserInfo({ credentials });
+                }
+                catch (e) {
+                    console.error('get user info error', e);
+                }
+                res = { data: { ...data, session: credentials, user }, error: null };
+            }
+            localSearch.delete('code');
+            localSearch.delete('state');
+            localSearch.delete('provider');
+            this.restoreUrlState(cacheData?.search === undefined ? `?${localSearch.toString()}` : cacheData.search, cacheData?.hash || location.hash);
+            try {
+                sessionStorage.removeItem(state);
+            }
+            catch {
+            }
+            return res;
+        }
+        catch (error) {
+            return { data, error: new AuthError(error) };
+        }
+    }
+    async signInCustom(params) {
+        const credentials = await this.config.request(ApiUrls.AUTH_SIGN_IN_CUSTOM, {
+            method: 'POST',
+            body: params,
+        });
+        await this.config.credentialsClient.setCredentials(credentials);
+        return Promise.resolve(credentials);
+    }
+    async signInWithWechat(params = {}) {
+        const credentials = await this.config.request(ApiUrls.AUTH_SIGN_IN_WITH_WECHAT_URL, {
+            method: 'POST',
+            body: params,
+        });
+        await this.config.credentialsClient.setCredentials(credentials);
+        return Promise.resolve(credentials);
+    }
+    async bindWithProvider(params, credentials) {
+        return this.config.request(ApiUrls.PROVIDER_BIND_URL, {
+            method: 'POST',
+            body: params,
+            withCredentials: true,
+            getCredentials: credentials ? () => credentials : undefined,
+        });
+    }
+    async getUserProfile(params) {
+        return this.getUserInfo(params);
+    }
+    async getUserInfo(params = {}) {
+        const res = this.getParamsByVersion(params, 'USER_ME_URL');
+        if (res.params?.query) {
+            const searchParams = new MyURLSearchParams(res.params.query);
+            res.url += `?${searchParams.toString()}`;
+        }
+        const userInfo = await this.config.request(res.url, {
+            method: 'GET',
+            withCredentials: true,
+            getCredentials: params.credentials ? () => params.credentials : undefined,
+        });
+        if (userInfo.sub) {
+            userInfo.uid = userInfo.sub;
+        }
+        if (userInfo.providers?.length) {
+            try {
+                if (typeof wx !== 'undefined' && wx.getAccountInfoSync) {
+                    const wxAppId = wx.getAccountInfoSync().miniProgram?.appId;
+                    const matched = userInfo.providers.find(p => p.id === wxAppId);
+                    if (matched?.provider_user_id) {
+                        userInfo.open_id = matched.provider_user_id;
+                    }
+                }
+            }
+            catch (e) { }
+        }
+        return userInfo;
+    }
+    async getWedaUserInfo() {
+        const userInfo = await this.config.request(ApiUrls.WEDA_USER_URL, {
+            method: 'GET',
+            withCredentials: true,
+        });
+        return userInfo;
+    }
+    async deleteMe(params) {
+        const res = this.getParamsByVersion(params, 'USER_ME_URL');
+        const url = `${res.url}?${Auth.parseParamsToSearch(res.params)}`;
+        return this.config.request(url, {
+            method: 'DELETE',
+            withCredentials: true,
+        });
+    }
+    async hasLoginState() {
+        try {
+            await this.config.credentialsClient.getAccessToken();
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    hasLoginStateSync() {
+        const credentials = this.config.credentialsClient.getCredentialsSync();
+        return credentials;
+    }
+    async getLoginState() {
+        return this.config.credentialsClient.getCredentialsAsync();
+    }
+    async transByProvider(params) {
+        return this.config.request(ApiUrls.USER_TRANS_BY_PROVIDER_URL, {
+            method: 'PATCH',
+            body: params,
+            withCredentials: true,
+        });
+    }
+    async grantToken(params) {
+        const res = this.getParamsByVersion(params, 'AUTH_TOKEN_URL');
+        return this.config.request(res.url, {
+            method: 'POST',
+            body: res.params,
+        });
+    }
+    async getProviders() {
+        return this.config.request(ApiUrls.PROVIDER_LIST, {
+            method: 'GET',
+            withCredentials: true,
+        });
+    }
+    async unbindProvider(params) {
+        return this.config.request(`${ApiUrls.PROVIDER_UNBIND_URL}/${params.provider_id}`, {
+            method: 'DELETE',
+            withCredentials: true,
+        });
+    }
+    async checkPassword(params) {
+        return this.config.request(`${ApiUrls.CHECK_PWD_URL}`, {
+            method: 'POST',
+            withCredentials: true,
+            body: params,
+        });
+    }
+    async editContact(params) {
+        return this.config.request(`${ApiUrls.BIND_CONTACT_URL}`, {
+            method: 'PATCH',
+            withCredentials: true,
+            body: params,
+        });
+    }
+    async setPassword(params) {
+        return this.config.request(`${ApiUrls.AUTH_SET_PASSWORD}`, {
+            method: 'PATCH',
+            withCredentials: true,
+            body: params,
+        });
+    }
+    async updatePasswordByOld(params) {
+        const sudoToken = await this.sudo({ password: params.old_password });
+        return this.setPassword({
+            sudo_token: sudoToken.sudo_token,
+            new_password: params.new_password,
+        });
+    }
+    async sudo(params) {
+        return this.config.request(`${ApiUrls.SUDO_URL}`, {
+            method: 'POST',
+            withCredentials: true,
+            body: params,
+        });
+    }
+    async sendVerificationCodeToCurrentUser(params) {
+        params.target = 'CUR_USER';
+        return this.config.request(ApiUrls.VERIFICATION_URL, {
+            method: 'POST',
+            body: params,
+            withCredentials: true,
+            withCaptcha: true,
+        });
+    }
+    async changeBoundProvider(params) {
+        return this.config.request(`${ApiUrls.PROVIDER_LIST}/${params.provider_id}/trans`, {
+            method: 'POST',
+            body: {
+                provider_trans_token: params.trans_token,
+            },
+            withCredentials: true,
+        });
+    }
+    async setUserProfile(params) {
+        return this.config.request(ApiUrls.USER_PRIFILE_URL, {
+            method: 'PATCH',
+            body: params,
+            withCredentials: true,
+        });
+    }
+    async updateUserBasicInfo(params) {
+        return this.config.request(ApiUrls.USER_BASIC_EDIT_URL, {
+            method: 'POST',
+            withCredentials: true,
+            body: params,
+        });
+    }
+    async queryUserProfile(params) {
+        const searchParams = new MyURLSearchParams(params);
+        return this.config.request(`${ApiUrls.USER_QUERY_URL}?${searchParams.toString()}`, {
+            method: 'GET',
+            withCredentials: true,
+        });
+    }
+    setCustomSignFunc(getTickFn) {
+        this.getCustomSignTicketFn = getTickFn;
+    }
+    async signInWithCustomTicket() {
+        const customSignTicketFn = this.getCustomSignTicketFn;
+        if (!customSignTicketFn) {
+            return Promise.reject({
+                error: 'failed_precondition',
+                error_description: 'please use setCustomSignFunc to set custom sign function',
+            });
+        }
+        const customTicket = await customSignTicketFn();
+        return this.signInCustom({
+            provider_id: 'custom',
+            ticket: customTicket,
+        });
+    }
+    async resetPassword(params) {
+        return this.config.request(ApiUrls.AUTH_RESET_PASSWORD, {
+            method: 'POST',
+            body: params,
+        });
+    }
+    async authorize(params) {
+        return this.config.request(ApiUrls.AUTHORIZE_URL, {
+            method: 'POST',
+            withCredentials: true,
+            body: params,
+        });
+    }
+    async authorizeDevice(params) {
+        return this.config.request(ApiUrls.AUTHORIZE_DEVICE_URL, {
+            method: 'POST',
+            withCredentials: true,
+            body: params,
+        });
+    }
+    async deviceAuthorize(params) {
+        return this.config.request(ApiUrls.AUTH_GET_DEVICE_CODE, {
+            method: 'POST',
+            body: params,
+        });
+    }
+    async authorizeInfo(params) {
+        const url = `${ApiUrls.AUTHORIZE_INFO_URL}?${Auth.parseParamsToSearch(params)}`;
+        let withBasicAuth = true;
+        let withCredentials = false;
+        const hasLogin = await this.hasLoginState();
+        if (hasLogin) {
+            withCredentials = true;
+            withBasicAuth = false;
+        }
+        return this.config.request(url, {
+            method: 'GET',
+            withBasicAuth,
+            withCredentials,
+        });
+    }
+    async checkUsername(params) {
+        return this.config.request(ApiUrls.CHECK_USERNAME, {
+            method: 'GET',
+            body: params,
+            withCredentials: true,
+        });
+    }
+    async checkIfUserExist(params) {
+        const searchParams = new MyURLSearchParams(params);
+        return this.config.request(`${ApiUrls.CHECK_IF_USER_EXIST}?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+    async loginScope() {
+        return this.config.credentialsClient.getScope();
+    }
+    async loginGroups() {
+        return this.config.credentialsClient.getGroups();
+    }
+    async refreshTokenForce(params) {
+        const credentials = await this.config.credentialsClient.getCredentials();
+        return await this.config.credentialsClient.refreshToken({
+            ...credentials,
+            version: params?.version || 'v1',
+        });
+    }
+    async getCredentials() {
+        return this.config.credentialsClient.getCredentials();
+    }
+    async getPublicKey() {
+        return this.config.request(ApiUrlsV2.AUTH_PUBLIC_KEY, {
+            method: 'POST',
+            body: {},
+        });
+    }
+    async getEncryptParams(params) {
+        const { isEncrypt } = params;
+        delete params.isEncrypt;
+        const payload = deepClone(params);
+        const encryptUtils = await getEncryptUtils(isEncrypt, this.config.adapter);
+        if (!encryptUtils) {
+            return params;
+        }
+        let publicKey = '';
+        let public_key_thumbprint = '';
+        try {
+            const res = await this.getPublicKey();
+            publicKey = res.public_key;
+            public_key_thumbprint = res.public_key_thumbprint;
+            if (!publicKey || !public_key_thumbprint) {
+                throw res;
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+        return {
+            params: encryptUtils.getEncryptInfo({ publicKey, payload }),
+            public_key_thumbprint,
+        };
+    }
+    async getProviderSubType() {
+        return this.config.request(ApiUrls.GET_PROVIDER_TYPE, {
+            method: 'POST',
+            body: {
+                provider_id: 'weda',
+            },
+        });
+    }
+    async verifyCaptchaData({ token, key }) {
+        return this.config.request(ApiUrls.VERIFY_CAPTCHA_DATA_URL, {
+            method: 'POST',
+            body: { token, key },
+            withCredentials: false,
+        });
+    }
+    async createCaptchaData({ state, redirect_uri = undefined }) {
+        return this.config.request(ApiUrls.CAPTCHA_DATA_URL, {
+            method: 'POST',
+            body: { state, redirect_uri },
+            withCredentials: false,
+        });
+    }
+    async getMiniProgramCode(params) {
+        return this.config.request(ApiUrls.GET_MINIPROGRAM_QRCODE, {
+            method: 'POST',
+            body: params,
+        });
+    }
+    async getMiniProgramQrCodeStatus(params) {
+        return this.config.request(ApiUrls.GET_MINIPROGRAM_QRCODE_STATUS, {
+            method: 'POST',
+            body: params,
+        });
+    }
+    async getUserBehaviorLog(params) {
+        const action = { LOGIN: 'query[action]=USER_LOGIN', MODIFY: 'ne_query[action]=USER_LOGIN' };
+        const url = `${ApiUrls.GET_USER_BEHAVIOR_LOG}?${action[params.type]}&limit=${params.limit}${params.page_token ? `&page_token=${params.page_token}` : ''}`;
+        return this.config.request(url, {
+            method: 'GET',
+            withCredentials: true,
+        });
+    }
+    async modifyPassword(params) {
+        let publicKey = '';
+        let public_key_thumbprint = '';
+        const encryptUtils = await getEncryptUtils(true, this.config.adapter);
+        if (!encryptUtils) {
+            throw new Error('do not support encrypt, a encrypt util required.');
+        }
+        try {
+            const res = await this.getPublicKey();
+            publicKey = res.public_key;
+            public_key_thumbprint = res.public_key_thumbprint;
+            if (!publicKey || !public_key_thumbprint) {
+                throw res;
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+        const encrypt_password = params.password ? encryptUtils.getEncryptInfo({ publicKey, payload: params.password }) : '';
+        const encrypt_new_password = encryptUtils.getEncryptInfo({ publicKey, payload: params.new_password });
+        return this.config.request(ApiUrls.USER_BASIC_EDIT_URL, {
+            method: 'POST',
+            withCredentials: true,
+            body: {
+                user_id: params.user_id,
+                encrypt_password,
+                encrypt_new_password,
+                public_key_thumbprint,
+            },
+        });
+    }
+    async modifyPasswordWithoutLogin(params) {
+        let publicKey = '';
+        let public_key_thumbprint = '';
+        const encryptUtils = await getEncryptUtils(true, this.config.adapter);
+        if (!encryptUtils) {
+            throw new Error('do not support encrypt, a encrypt util required.');
+        }
+        try {
+            const res = await this.getPublicKey();
+            publicKey = res.public_key;
+            public_key_thumbprint = res.public_key_thumbprint;
+            if (!publicKey || !public_key_thumbprint) {
+                throw res;
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+        const encrypt_password = params.password ? encryptUtils.getEncryptInfo({ publicKey, payload: params.password }) : '';
+        const encrypt_new_password = encryptUtils.getEncryptInfo({ publicKey, payload: params.new_password });
+        return this.config.request(ApiUrlsV2.AUTH_RESET_PASSWORD, {
+            method: 'POST',
+            body: {
+                username: params.username,
+                password: encrypt_password,
+                new_password: encrypt_new_password,
+                public_key_thumbprint,
+            },
+        });
+    }
+    restoreUrlState(search, hash) {
+        if (search === undefined)
+            return;
+        try {
+            const url = new URL(window.location.href);
+            url.search = search;
+            url.hash = hash || '';
+            window.history.replaceState(null, '', url.toString());
+            window.location.replace(url.toString());
+        }
+        catch {
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apis.js","sourceRoot":"","sources":["../../../src/auth/apis.ts"],"names":[],"mappings":"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"}