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

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

@@ -0,0 +1,1280 @@
+'use strict';
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth = void 0;
+var consts_1 = require("./consts");
+var oauth2client_1 = require("../oauth2client/oauth2client");
+var captcha_1 = require("../captcha/captcha");
+var utils_1 = require("../utils");
+var urlSearchParams_1 = __importDefault(require("../utils/urlSearchParams"));
+var auth_error_1 = require("./auth-error");
+function getEncryptUtils(isEncrypt, adapter) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function () {
+        var getUtils;
+        var _this = this;
+        return __generator(this, function (_b) {
+            getUtils = function () { return __awaiter(_this, void 0, void 0, function () {
+                var utils, error_1, utils, error_2;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 1, , 6]);
+                            utils = require('../utils/encrypt');
+                            return [2, utils];
+                        case 1:
+                            error_1 = _a.sent();
+                            _a.label = 2;
+                        case 2:
+                            _a.trys.push([2, 4, , 5]);
+                            return [4, import('../utils/encrypt')];
+                        case 3:
+                            utils = _a.sent();
+                            return [2, utils];
+                        case 4:
+                            error_2 = _a.sent();
+                            return [2];
+                        case 5: return [3, 6];
+                        case 6: return [2];
+                    }
+                });
+            }); };
+            try {
+                if ((((_a = adapter === null || adapter === void 0 ? void 0 : adapter.root) === null || _a === void 0 ? void 0 : _a.globalThis) || globalThis).IS_MP_BUILD) {
+                    return [2];
+                }
+                if (!process.env.IS_MP_BUILD && isEncrypt) {
+                    return [2, getUtils()];
+                }
+            }
+            catch (error) {
+                if (isEncrypt) {
+                    return [2, getUtils()];
+                }
+            }
+            return [2];
+        });
+    });
+}
+var Auth = (function () {
+    function Auth(opts) {
+        var request = opts.request;
+        var oAuth2Client = opts.credentialsClient;
+        if (!oAuth2Client) {
+            var 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_1.OAuth2Client(initOptions);
+        }
+        if (!request) {
+            var baseRequest = oAuth2Client.request.bind(oAuth2Client);
+            var captcha = new captcha_1.Captcha(__assign({ 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: request,
+            credentialsClient: oAuth2Client,
+            storage: opts.storage || oauth2client_1.defaultStorage,
+            adapter: opts.adapter,
+        };
+    }
+    Auth.parseParamsToSearch = function (params) {
+        Object.keys(params).forEach(function (key) {
+            if (!params[key]) {
+                delete params[key];
+            }
+        });
+        var searchParams = new urlSearchParams_1.default(params);
+        return searchParams.toString();
+    };
+    Auth.prototype.getParamsByVersion = function (params, key) {
+        var _a;
+        var paramsTemp = (0, utils_1.deepClone)(params);
+        var url = ((_a = { v2: consts_1.ApiUrlsV2 }[paramsTemp === null || paramsTemp === void 0 ? void 0 : paramsTemp.version]) === null || _a === void 0 ? void 0 : _a[key]) || consts_1.ApiUrls[key];
+        if (paramsTemp) {
+            delete paramsTemp.version;
+        }
+        return { params: paramsTemp, url: url };
+    };
+    Auth.prototype.signIn = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var version, res, body, credentials;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        version = params.version || 'v1';
+                        res = this.getParamsByVersion(params, 'AUTH_SIGN_IN_URL');
+                        if (res.params.query) {
+                            delete res.params.query;
+                        }
+                        return [4, this.getEncryptParams(res.params)];
+                    case 1:
+                        body = _a.sent();
+                        return [4, this.config.request(res.url, {
+                                method: 'POST',
+                                body: body,
+                            })];
+                    case 2:
+                        credentials = _a.sent();
+                        return [4, this.config.credentialsClient.setCredentials(__assign(__assign({}, credentials), { version: version }))];
+                    case 3:
+                        _a.sent();
+                        return [2, Promise.resolve(credentials)];
+                }
+            });
+        });
+    };
+    Auth.prototype.signInAnonymously = function (data, useWxCloud) {
+        if (data === void 0) { data = {}; }
+        if (useWxCloud === void 0) { useWxCloud = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var credentials;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.config.request(consts_1.ApiUrls.AUTH_SIGN_IN_ANONYMOUSLY_URL, {
+                            method: 'POST',
+                            body: data,
+                            useWxCloud: useWxCloud,
+                        })];
+                    case 1:
+                        credentials = _a.sent();
+                        return [4, this.config.credentialsClient.setCredentials(credentials)];
+                    case 2:
+                        _a.sent();
+                        return [2, Promise.resolve(credentials)];
+                }
+            });
+        });
+    };
+    Auth.prototype.signUp = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.config.request(consts_1.ApiUrls.AUTH_SIGN_UP_URL, {
+                            method: 'POST',
+                            body: params,
+                        })];
+                    case 1:
+                        data = _a.sent();
+                        return [4, this.config.credentialsClient.setCredentials(data)];
+                    case 2:
+                        _a.sent();
+                        return [2, Promise.resolve(data)];
+                }
+            });
+        });
+    };
+    Auth.prototype.signOut = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resp, err_1, accessToken, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        resp = {};
+                        if (!params) return [3, 6];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4, this.config.request(consts_1.ApiUrls.AUTH_SIGNOUT_URL, {
+                                method: 'POST',
+                                withCredentials: true,
+                                body: params,
+                            })];
+                    case 2:
+                        resp = _a.sent();
+                        return [3, 4];
+                    case 3:
+                        err_1 = _a.sent();
+                        if (err_1.error !== consts_1.ErrorType.UNAUTHENTICATED) {
+                            console.log('sign_out_error', err_1);
+                        }
+                        return [3, 4];
+                    case 4: return [4, this.config.credentialsClient.setCredentials()];
+                    case 5:
+                        _a.sent();
+                        return [2, resp];
+                    case 6: return [4, this.config.credentialsClient.getAccessToken()];
+                    case 7:
+                        accessToken = _a.sent();
+                        return [4, this.config.request(consts_1.ApiUrls.AUTH_REVOKE_URL, {
+                                method: 'POST',
+                                body: {
+                                    token: accessToken,
+                                },
+                            })];
+                    case 8:
+                        data = _a.sent();
+                        return [4, this.config.credentialsClient.setCredentials()];
+                    case 9:
+                        _a.sent();
+                        return [2, Promise.resolve(data)];
+                }
+            });
+        });
+    };
+    Auth.prototype.revokeAllDevices = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.config.request(consts_1.ApiUrls.AUTH_REVOKE_ALL_URL, {
+                            method: 'DELETE',
+                            withCredentials: true,
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    Auth.prototype.revokeDevice = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.config.request(consts_1.ApiUrls.AUTHORIZED_DEVICES_DELETE_URL + params.device_id, {
+                            method: 'DELETE',
+                            withCredentials: true,
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    Auth.prototype.getVerification = function (params, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var withCredentials, hasLogin, body;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        withCredentials = false;
+                        if (!(params.target === 'CUR_USER')) return [3, 1];
+                        withCredentials = true;
+                        return [3, 3];
+                    case 1: return [4, this.hasLoginState()];
+                    case 2:
+                        hasLogin = _a.sent();
+                        if (hasLogin) {
+                            withCredentials = true;
+                        }
+                        _a.label = 3;
+                    case 3:
+                        body = (0, utils_1.deepClone)(params);
+                        if (body.phone_number && !/^\+\d{1,3}\s+\d+/.test(body.phone_number)) {
+                            body.phone_number = "+86 ".concat(body.phone_number);
+                        }
+                        return [2, this.config.request(consts_1.ApiUrls.VERIFICATION_URL, {
+                                method: 'POST',
+                                body: body,
+                                withCaptcha: (options === null || options === void 0 ? void 0 : options.withCaptcha) || false,
+                                withCredentials: withCredentials,
+                            })];
+                }
+            });
+        });
+    };
+    Auth.prototype.verify = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        res = this.getParamsByVersion(params, 'VERIFY_URL');
+                        return [4, this.config.request(res.url, {
+                                method: 'POST',
+                                body: res.params,
+                            })];
+                    case 1:
+                        data = _a.sent();
+                        if (!((params === null || params === void 0 ? void 0 : params.version) === 'v2')) return [3, 3];
+                        return [4, this.config.credentialsClient.setCredentials(__assign(__assign({}, data), { version: 'v2' }))];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [2, data];
+                }
+            });
+        });
+    };
+    Auth.prototype.genProviderRedirectUri = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var redirect_uri, _a, otherParams, restParams, url;
+            return __generator(this, function (_b) {
+                redirect_uri = params.provider_redirect_uri, _a = params.other_params, otherParams = _a === void 0 ? {} : _a, restParams = __rest(params, ["provider_redirect_uri", "other_params"]);
+                if (redirect_uri && !restParams.redirect_uri) {
+                    restParams.redirect_uri = redirect_uri;
+                }
+                url = "".concat(consts_1.ApiUrls.PROVIDER_URI_URL, "?").concat(Auth.parseParamsToSearch(restParams));
+                Object.keys(otherParams).forEach(function (key) {
+                    var value = otherParams[key];
+                    if (key === 'sign_out_uri' && !((value === null || value === void 0 ? void 0 : value.length) > 0)) {
+                        return;
+                    }
+                    url += "&other_params[".concat(key, "]=").concat(encodeURIComponent(value));
+                });
+                return [2, this.config.request(url, {
+                        method: 'GET',
+                    })];
+            });
+        });
+    };
+    Auth.prototype.grantProviderToken = function (params, useWxCloud) {
+        if (useWxCloud === void 0) { useWxCloud = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.PROVIDER_TOKEN_URL, {
+                        method: 'POST',
+                        body: params,
+                        useWxCloud: useWxCloud,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.patchProviderToken = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.PROVIDER_TOKEN_URL, {
+                        method: 'PATCH',
+                        body: params,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.signInWithProvider = function (params, useWxCloud) {
+        if (useWxCloud === void 0) { useWxCloud = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var res, credentials;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        res = this.getParamsByVersion(params, 'AUTH_SIGN_IN_WITH_PROVIDER_URL');
+                        return [4, this.config.request(res.url, {
+                                method: 'POST',
+                                body: res.params,
+                                useWxCloud: useWxCloud,
+                            })];
+                    case 1:
+                        credentials = _a.sent();
+                        return [4, this.config.credentialsClient.setCredentials(__assign(__assign({}, credentials), { version: (params === null || params === void 0 ? void 0 : params.version) || 'v1' }))];
+                    case 2:
+                        _a.sent();
+                        return [2, Promise.resolve(credentials)];
+                }
+            });
+        });
+    };
+    Auth.prototype.toBindIdentity = function (params) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var credentials, _c, res, error_3;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _c = params.credentials;
+                        if (_c) return [3, 2];
+                        return [4, this.config.credentialsClient.localCredentials.getCredentials()];
+                    case 1:
+                        _c = (_d.sent());
+                        _d.label = 2;
+                    case 2:
+                        credentials = _c;
+                        _d.label = 3;
+                    case 3:
+                        _d.trys.push([3, 5, , 6]);
+                        return [4, this.bindWithProvider({
+                                provider_token: params.provider_token,
+                            }, credentials)];
+                    case 4:
+                        _d.sent();
+                        res = { data: { type: consts_1.OAUTH_TYPE.BIND_IDENTITY, provider: params.provider }, error: null };
+                        return [3, 6];
+                    case 5:
+                        error_3 = _d.sent();
+                        res = { data: { type: consts_1.OAUTH_TYPE.BIND_IDENTITY }, error: new auth_error_1.AuthError(error_3) };
+                        return [3, 6];
+                    case 6:
+                        if (params.fireEvent) {
+                            (_b = (_a = this.config.eventBus) === null || _a === void 0 ? void 0 : _a.fire) === null || _b === void 0 ? void 0 : _b.call(_a, consts_1.EVENTS.AUTH_STATE_CHANGED, {
+                                event: consts_1.AUTH_STATE_CHANGED_TYPE.BIND_IDENTITY,
+                                info: res,
+                            });
+                        }
+                        return [2, res];
+                }
+            });
+        });
+    };
+    Auth.prototype.getInitialSession = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, localSearch, code, state, cacheData, errorParam, errorDescription, provider, redirectUri, providerToken, credentials, user, res, e_1, error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        data = {};
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 12, , 13]);
+                        if (typeof window === 'undefined' || typeof document === 'undefined') {
+                            return [2, { data: null, error: null }];
+                        }
+                        localSearch = new URLSearchParams(location === null || location === void 0 ? void 0 : location.search);
+                        code = localSearch.get('code');
+                        state = localSearch.get('state');
+                        if (!code || !state) {
+                            return [2, { data: null, error: null }];
+                        }
+                        cacheData = null;
+                        try {
+                            cacheData = JSON.parse(sessionStorage.getItem(state) || 'null');
+                        }
+                        catch (_b) {
+                        }
+                        data = { type: cacheData === null || cacheData === void 0 ? void 0 : cacheData.type };
+                        errorParam = localSearch.get('error');
+                        errorDescription = localSearch.get('error_description');
+                        if (errorParam || errorDescription) {
+                            return [2, {
+                                    data: data,
+                                    error: new auth_error_1.AuthError({ message: errorDescription || errorParam || 'Unknown error from OAuth provider' }),
+                                }];
+                        }
+                        provider = (cacheData === null || cacheData === void 0 ? void 0 : cacheData.provider) || localSearch.get('provider');
+                        if (!provider) {
+                            return [2, { data: data, error: new auth_error_1.AuthError({ message: 'Provider is required for OAuth verification' }) }];
+                        }
+                        redirectUri = location.origin + location.pathname;
+                        return [4, this.grantProviderToken({
+                                provider_id: provider,
+                                provider_redirect_uri: redirectUri,
+                                provider_code: code,
+                            })];
+                    case 2:
+                        providerToken = (_a.sent()).provider_token;
+                        credentials = void 0;
+                        user = null;
+                        res = void 0;
+                        if (!(cacheData.type === consts_1.OAUTH_TYPE.BIND_IDENTITY)) return [3, 5];
+                        return [4, this.config.credentialsClient.localCredentials.getCredentials()];
+                    case 3:
+                        credentials = _a.sent();
+                        return [4, this.toBindIdentity({ provider: provider, provider_token: providerToken, credentials: credentials })];
+                    case 4:
+                        res = _a.sent();
+                        return [3, 11];
+                    case 5:
+                        if (!(cacheData.type === consts_1.OAUTH_TYPE.SIGN_IN)) return [3, 11];
+                        res = this.getParamsByVersion({ provider: provider }, 'AUTH_SIGN_IN_WITH_PROVIDER_URL');
+                        return [4, this.config.request(res.url, {
+                                method: 'POST',
+                                body: { provider_token: providerToken },
+                            })];
+                    case 6:
+                        credentials = _a.sent();
+                        _a.label = 7;
+                    case 7:
+                        _a.trys.push([7, 9, , 10]);
+                        return [4, this.getUserInfo({ credentials: credentials })];
+                    case 8:
+                        user = _a.sent();
+                        return [3, 10];
+                    case 9:
+                        e_1 = _a.sent();
+                        console.error('get user info error', e_1);
+                        return [3, 10];
+                    case 10:
+                        res = { data: __assign(__assign({}, data), { session: credentials, user: user }), error: null };
+                        _a.label = 11;
+                    case 11:
+                        localSearch.delete('code');
+                        localSearch.delete('state');
+                        localSearch.delete('provider');
+                        this.restoreUrlState((cacheData === null || cacheData === void 0 ? void 0 : cacheData.search) === undefined ? "?".concat(localSearch.toString()) : cacheData.search, (cacheData === null || cacheData === void 0 ? void 0 : cacheData.hash) || location.hash);
+                        try {
+                            sessionStorage.removeItem(state);
+                        }
+                        catch (_c) {
+                        }
+                        return [2, res];
+                    case 12:
+                        error_4 = _a.sent();
+                        return [2, { data: data, error: new auth_error_1.AuthError(error_4) }];
+                    case 13: return [2];
+                }
+            });
+        });
+    };
+    Auth.prototype.signInCustom = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var credentials;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.config.request(consts_1.ApiUrls.AUTH_SIGN_IN_CUSTOM, {
+                            method: 'POST',
+                            body: params,
+                        })];
+                    case 1:
+                        credentials = _a.sent();
+                        return [4, this.config.credentialsClient.setCredentials(credentials)];
+                    case 2:
+                        _a.sent();
+                        return [2, Promise.resolve(credentials)];
+                }
+            });
+        });
+    };
+    Auth.prototype.signInWithWechat = function (params) {
+        if (params === void 0) { params = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var credentials;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.config.request(consts_1.ApiUrls.AUTH_SIGN_IN_WITH_WECHAT_URL, {
+                            method: 'POST',
+                            body: params,
+                        })];
+                    case 1:
+                        credentials = _a.sent();
+                        return [4, this.config.credentialsClient.setCredentials(credentials)];
+                    case 2:
+                        _a.sent();
+                        return [2, Promise.resolve(credentials)];
+                }
+            });
+        });
+    };
+    Auth.prototype.bindWithProvider = function (params, credentials) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.PROVIDER_BIND_URL, {
+                        method: 'POST',
+                        body: params,
+                        withCredentials: true,
+                        getCredentials: credentials ? function () { return credentials; } : undefined,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.getUserProfile = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.getUserInfo(params)];
+            });
+        });
+    };
+    Auth.prototype.getUserInfo = function (params) {
+        var _a, _b, _c;
+        if (params === void 0) { params = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var res, searchParams, userInfo, wxAppId_1, matched;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        res = this.getParamsByVersion(params, 'USER_ME_URL');
+                        if ((_a = res.params) === null || _a === void 0 ? void 0 : _a.query) {
+                            searchParams = new urlSearchParams_1.default(res.params.query);
+                            res.url += "?".concat(searchParams.toString());
+                        }
+                        return [4, this.config.request(res.url, {
+                                method: 'GET',
+                                withCredentials: true,
+                                getCredentials: params.credentials ? function () { return params.credentials; } : undefined,
+                            })];
+                    case 1:
+                        userInfo = _d.sent();
+                        if (userInfo.sub) {
+                            userInfo.uid = userInfo.sub;
+                        }
+                        if ((_b = userInfo.providers) === null || _b === void 0 ? void 0 : _b.length) {
+                            try {
+                                if (typeof wx !== 'undefined' && wx.getAccountInfoSync) {
+                                    wxAppId_1 = (_c = wx.getAccountInfoSync().miniProgram) === null || _c === void 0 ? void 0 : _c.appId;
+                                    matched = userInfo.providers.find(function (p) { return p.id === wxAppId_1; });
+                                    if (matched === null || matched === void 0 ? void 0 : matched.provider_user_id) {
+                                        userInfo.open_id = matched.provider_user_id;
+                                    }
+                                }
+                            }
+                            catch (e) { }
+                        }
+                        return [2, userInfo];
+                }
+            });
+        });
+    };
+    Auth.prototype.getWedaUserInfo = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var userInfo;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.config.request(consts_1.ApiUrls.WEDA_USER_URL, {
+                            method: 'GET',
+                            withCredentials: true,
+                        })];
+                    case 1:
+                        userInfo = _a.sent();
+                        return [2, userInfo];
+                }
+            });
+        });
+    };
+    Auth.prototype.deleteMe = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res, url;
+            return __generator(this, function (_a) {
+                res = this.getParamsByVersion(params, 'USER_ME_URL');
+                url = "".concat(res.url, "?").concat(Auth.parseParamsToSearch(res.params));
+                return [2, this.config.request(url, {
+                        method: 'DELETE',
+                        withCredentials: true,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.hasLoginState = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4, this.config.credentialsClient.getAccessToken()];
+                    case 1:
+                        _a.sent();
+                        return [2, true];
+                    case 2:
+                        error_5 = _a.sent();
+                        return [2, false];
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    Auth.prototype.hasLoginStateSync = function () {
+        var credentials = this.config.credentialsClient.getCredentialsSync();
+        return credentials;
+    };
+    Auth.prototype.getLoginState = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.credentialsClient.getCredentialsAsync()];
+            });
+        });
+    };
+    Auth.prototype.transByProvider = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.USER_TRANS_BY_PROVIDER_URL, {
+                        method: 'PATCH',
+                        body: params,
+                        withCredentials: true,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.grantToken = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                res = this.getParamsByVersion(params, 'AUTH_TOKEN_URL');
+                return [2, this.config.request(res.url, {
+                        method: 'POST',
+                        body: res.params,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.getProviders = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.PROVIDER_LIST, {
+                        method: 'GET',
+                        withCredentials: true,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.unbindProvider = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request("".concat(consts_1.ApiUrls.PROVIDER_UNBIND_URL, "/").concat(params.provider_id), {
+                        method: 'DELETE',
+                        withCredentials: true,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.checkPassword = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request("".concat(consts_1.ApiUrls.CHECK_PWD_URL), {
+                        method: 'POST',
+                        withCredentials: true,
+                        body: params,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.editContact = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request("".concat(consts_1.ApiUrls.BIND_CONTACT_URL), {
+                        method: 'PATCH',
+                        withCredentials: true,
+                        body: params,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.setPassword = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request("".concat(consts_1.ApiUrls.AUTH_SET_PASSWORD), {
+                        method: 'PATCH',
+                        withCredentials: true,
+                        body: params,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.updatePasswordByOld = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sudoToken;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.sudo({ password: params.old_password })];
+                    case 1:
+                        sudoToken = _a.sent();
+                        return [2, this.setPassword({
+                                sudo_token: sudoToken.sudo_token,
+                                new_password: params.new_password,
+                            })];
+                }
+            });
+        });
+    };
+    Auth.prototype.sudo = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request("".concat(consts_1.ApiUrls.SUDO_URL), {
+                        method: 'POST',
+                        withCredentials: true,
+                        body: params,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.sendVerificationCodeToCurrentUser = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                params.target = 'CUR_USER';
+                return [2, this.config.request(consts_1.ApiUrls.VERIFICATION_URL, {
+                        method: 'POST',
+                        body: params,
+                        withCredentials: true,
+                        withCaptcha: true,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.changeBoundProvider = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request("".concat(consts_1.ApiUrls.PROVIDER_LIST, "/").concat(params.provider_id, "/trans"), {
+                        method: 'POST',
+                        body: {
+                            provider_trans_token: params.trans_token,
+                        },
+                        withCredentials: true,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.setUserProfile = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.USER_PRIFILE_URL, {
+                        method: 'PATCH',
+                        body: params,
+                        withCredentials: true,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.updateUserBasicInfo = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.USER_BASIC_EDIT_URL, {
+                        method: 'POST',
+                        withCredentials: true,
+                        body: params,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.queryUserProfile = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var searchParams;
+            return __generator(this, function (_a) {
+                searchParams = new urlSearchParams_1.default(params);
+                return [2, this.config.request("".concat(consts_1.ApiUrls.USER_QUERY_URL, "?").concat(searchParams.toString()), {
+                        method: 'GET',
+                        withCredentials: true,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.setCustomSignFunc = function (getTickFn) {
+        this.getCustomSignTicketFn = getTickFn;
+    };
+    Auth.prototype.signInWithCustomTicket = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var customSignTicketFn, customTicket;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        customSignTicketFn = this.getCustomSignTicketFn;
+                        if (!customSignTicketFn) {
+                            return [2, Promise.reject({
+                                    error: 'failed_precondition',
+                                    error_description: 'please use setCustomSignFunc to set custom sign function',
+                                })];
+                        }
+                        return [4, customSignTicketFn()];
+                    case 1:
+                        customTicket = _a.sent();
+                        return [2, this.signInCustom({
+                                provider_id: 'custom',
+                                ticket: customTicket,
+                            })];
+                }
+            });
+        });
+    };
+    Auth.prototype.resetPassword = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.AUTH_RESET_PASSWORD, {
+                        method: 'POST',
+                        body: params,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.authorize = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.AUTHORIZE_URL, {
+                        method: 'POST',
+                        withCredentials: true,
+                        body: params,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.authorizeDevice = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.AUTHORIZE_DEVICE_URL, {
+                        method: 'POST',
+                        withCredentials: true,
+                        body: params,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.deviceAuthorize = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.AUTH_GET_DEVICE_CODE, {
+                        method: 'POST',
+                        body: params,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.authorizeInfo = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, withBasicAuth, withCredentials, hasLogin;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        url = "".concat(consts_1.ApiUrls.AUTHORIZE_INFO_URL, "?").concat(Auth.parseParamsToSearch(params));
+                        withBasicAuth = true;
+                        withCredentials = false;
+                        return [4, this.hasLoginState()];
+                    case 1:
+                        hasLogin = _a.sent();
+                        if (hasLogin) {
+                            withCredentials = true;
+                            withBasicAuth = false;
+                        }
+                        return [2, this.config.request(url, {
+                                method: 'GET',
+                                withBasicAuth: withBasicAuth,
+                                withCredentials: withCredentials,
+                            })];
+                }
+            });
+        });
+    };
+    Auth.prototype.checkUsername = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.CHECK_USERNAME, {
+                        method: 'GET',
+                        body: params,
+                        withCredentials: true,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.checkIfUserExist = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var searchParams;
+            return __generator(this, function (_a) {
+                searchParams = new urlSearchParams_1.default(params);
+                return [2, this.config.request("".concat(consts_1.ApiUrls.CHECK_IF_USER_EXIST, "?").concat(searchParams.toString()), {
+                        method: 'GET',
+                    })];
+            });
+        });
+    };
+    Auth.prototype.loginScope = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.credentialsClient.getScope()];
+            });
+        });
+    };
+    Auth.prototype.loginGroups = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.credentialsClient.getGroups()];
+            });
+        });
+    };
+    Auth.prototype.refreshTokenForce = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var credentials;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.config.credentialsClient.getCredentials()];
+                    case 1:
+                        credentials = _a.sent();
+                        return [4, this.config.credentialsClient.refreshToken(__assign(__assign({}, credentials), { version: (params === null || params === void 0 ? void 0 : params.version) || 'v1' }))];
+                    case 2: return [2, _a.sent()];
+                }
+            });
+        });
+    };
+    Auth.prototype.getCredentials = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.credentialsClient.getCredentials()];
+            });
+        });
+    };
+    Auth.prototype.getPublicKey = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrlsV2.AUTH_PUBLIC_KEY, {
+                        method: 'POST',
+                        body: {},
+                    })];
+            });
+        });
+    };
+    Auth.prototype.getEncryptParams = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var isEncrypt, payload, encryptUtils, publicKey, public_key_thumbprint, res, error_6;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        isEncrypt = params.isEncrypt;
+                        delete params.isEncrypt;
+                        payload = (0, utils_1.deepClone)(params);
+                        return [4, getEncryptUtils(isEncrypt, this.config.adapter)];
+                    case 1:
+                        encryptUtils = _a.sent();
+                        if (!encryptUtils) {
+                            return [2, params];
+                        }
+                        publicKey = '';
+                        public_key_thumbprint = '';
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4, this.getPublicKey()];
+                    case 3:
+                        res = _a.sent();
+                        publicKey = res.public_key;
+                        public_key_thumbprint = res.public_key_thumbprint;
+                        if (!publicKey || !public_key_thumbprint) {
+                            throw res;
+                        }
+                        return [3, 5];
+                    case 4:
+                        error_6 = _a.sent();
+                        throw error_6;
+                    case 5: return [2, {
+                            params: encryptUtils.getEncryptInfo({ publicKey: publicKey, payload: payload }),
+                            public_key_thumbprint: public_key_thumbprint,
+                        }];
+                }
+            });
+        });
+    };
+    Auth.prototype.getProviderSubType = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.GET_PROVIDER_TYPE, {
+                        method: 'POST',
+                        body: {
+                            provider_id: 'weda',
+                        },
+                    })];
+            });
+        });
+    };
+    Auth.prototype.verifyCaptchaData = function (_a) {
+        var token = _a.token, key = _a.key;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                return [2, this.config.request(consts_1.ApiUrls.VERIFY_CAPTCHA_DATA_URL, {
+                        method: 'POST',
+                        body: { token: token, key: key },
+                        withCredentials: false,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.createCaptchaData = function (_a) {
+        var state = _a.state, _b = _a.redirect_uri, redirect_uri = _b === void 0 ? undefined : _b;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_c) {
+                return [2, this.config.request(consts_1.ApiUrls.CAPTCHA_DATA_URL, {
+                        method: 'POST',
+                        body: { state: state, redirect_uri: redirect_uri },
+                        withCredentials: false,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.getMiniProgramCode = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.GET_MINIPROGRAM_QRCODE, {
+                        method: 'POST',
+                        body: params,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.getMiniProgramQrCodeStatus = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, this.config.request(consts_1.ApiUrls.GET_MINIPROGRAM_QRCODE_STATUS, {
+                        method: 'POST',
+                        body: params,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.getUserBehaviorLog = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var action, url;
+            return __generator(this, function (_a) {
+                action = { LOGIN: 'query[action]=USER_LOGIN', MODIFY: 'ne_query[action]=USER_LOGIN' };
+                url = "".concat(consts_1.ApiUrls.GET_USER_BEHAVIOR_LOG, "?").concat(action[params.type], "&limit=").concat(params.limit).concat(params.page_token ? "&page_token=".concat(params.page_token) : '');
+                return [2, this.config.request(url, {
+                        method: 'GET',
+                        withCredentials: true,
+                    })];
+            });
+        });
+    };
+    Auth.prototype.modifyPassword = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var publicKey, public_key_thumbprint, encryptUtils, res, error_7, encrypt_password, encrypt_new_password;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        publicKey = '';
+                        public_key_thumbprint = '';
+                        return [4, getEncryptUtils(true, this.config.adapter)];
+                    case 1:
+                        encryptUtils = _a.sent();
+                        if (!encryptUtils) {
+                            throw new Error('do not support encrypt, a encrypt util required.');
+                        }
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4, this.getPublicKey()];
+                    case 3:
+                        res = _a.sent();
+                        publicKey = res.public_key;
+                        public_key_thumbprint = res.public_key_thumbprint;
+                        if (!publicKey || !public_key_thumbprint) {
+                            throw res;
+                        }
+                        return [3, 5];
+                    case 4:
+                        error_7 = _a.sent();
+                        throw error_7;
+                    case 5:
+                        encrypt_password = params.password ? encryptUtils.getEncryptInfo({ publicKey: publicKey, payload: params.password }) : '';
+                        encrypt_new_password = encryptUtils.getEncryptInfo({ publicKey: publicKey, payload: params.new_password });
+                        return [2, this.config.request(consts_1.ApiUrls.USER_BASIC_EDIT_URL, {
+                                method: 'POST',
+                                withCredentials: true,
+                                body: {
+                                    user_id: params.user_id,
+                                    encrypt_password: encrypt_password,
+                                    encrypt_new_password: encrypt_new_password,
+                                    public_key_thumbprint: public_key_thumbprint,
+                                },
+                            })];
+                }
+            });
+        });
+    };
+    Auth.prototype.modifyPasswordWithoutLogin = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var publicKey, public_key_thumbprint, encryptUtils, res, error_8, encrypt_password, encrypt_new_password;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        publicKey = '';
+                        public_key_thumbprint = '';
+                        return [4, getEncryptUtils(true, this.config.adapter)];
+                    case 1:
+                        encryptUtils = _a.sent();
+                        if (!encryptUtils) {
+                            throw new Error('do not support encrypt, a encrypt util required.');
+                        }
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4, this.getPublicKey()];
+                    case 3:
+                        res = _a.sent();
+                        publicKey = res.public_key;
+                        public_key_thumbprint = res.public_key_thumbprint;
+                        if (!publicKey || !public_key_thumbprint) {
+                            throw res;
+                        }
+                        return [3, 5];
+                    case 4:
+                        error_8 = _a.sent();
+                        throw error_8;
+                    case 5:
+                        encrypt_password = params.password ? encryptUtils.getEncryptInfo({ publicKey: publicKey, payload: params.password }) : '';
+                        encrypt_new_password = encryptUtils.getEncryptInfo({ publicKey: publicKey, payload: params.new_password });
+                        return [2, this.config.request(consts_1.ApiUrlsV2.AUTH_RESET_PASSWORD, {
+                                method: 'POST',
+                                body: {
+                                    username: params.username,
+                                    password: encrypt_password,
+                                    new_password: encrypt_new_password,
+                                    public_key_thumbprint: public_key_thumbprint,
+                                },
+                            })];
+                }
+            });
+        });
+    };
+    Auth.prototype.restoreUrlState = function (search, hash) {
+        if (search === undefined)
+            return;
+        try {
+            var url = new URL(window.location.href);
+            url.search = search;
+            url.hash = hash || '';
+            window.history.replaceState(null, '', url.toString());
+            window.location.replace(url.toString());
+        }
+        catch (_a) {
+        }
+    };
+    return Auth;
+}());
+exports.Auth = Auth;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apis.js","sourceRoot":"","sources":["../../../src/auth/apis.ts"],"names":[],"mappings":"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","sourcesContent":["'use strict'\n\nimport { ApiUrls, ApiUrlsV2, AUTH_STATE_CHANGED_TYPE, ErrorType, EVENTS, OAUTH_TYPE } from './consts'\nimport {\n  GetVerificationRequest,\n  GetVerificationResponse,\n  UserProfile,\n  UserInfo,\n  SignInRequest,\n  SignUpRequest,\n  VerifyRequest,\n  VerifyResponse,\n  GenProviderRedirectUriRequest,\n  GenProviderRedirectUriResponse,\n  GrantProviderTokenRequest,\n  GrantProviderTokenResponse,\n  PatchProviderTokenRequest,\n  PatchProviderTokenResponse,\n  SignInWithProviderRequest,\n  SignInCustomRequest,\n  BindWithProviderRequest,\n  TransByProviderRequest,\n  GrantTokenRequest,\n  UnbindProviderRequest,\n  CheckPasswordRequest,\n  SetPasswordRequest,\n  ChangeBoundProviderRequest,\n  ChangeBoundProviderResponse,\n  UpdatePasswordRequest,\n  SudoResponse,\n  SudoRequest,\n  GetCustomSignTicketFn,\n  QueryUserProfileRequest,\n  QueryUserProfileResponse,\n  ResetPasswordRequest,\n  DeviceAuthorizeRequest,\n  DeviceAuthorizeResponse,\n  CheckUsernameRequest,\n  CheckIfUserExistRequest,\n  CheckIfUserExistResponse,\n  WithSudoRequest,\n  PublicKey,\n  EncryptParams,\n  ProviderSubType,\n  GetMiniProgramQrCodeRequest,\n  GetMiniProgramQrCodeStatusRequest,\n  GetMiniProgramQrCodeResponse,\n  GetMiniProgramQrCodeStatusResponse,\n  ModifyUserBasicInfoRequest,\n  EditContactRequest,\n  AuthorizeInfoRequest,\n  AuthorizeInfoResponse,\n  AuthorizeDeviceRequest,\n  AuthorizeRequest,\n  AuthorizeResponse,\n  GetUserBehaviorLog,\n  GetUserBehaviorLogRes,\n  RevokeDeviceRequest,\n  SignoutResponse,\n  ProvidersResponse,\n  SignoutRequest,\n  ModifyPasswordWithoutLoginRequest,\n} from './models'\nimport { SimpleStorage, RequestFunction } from '../oauth2client/interface'\nimport { OAuth2Client, defaultStorage } from '../oauth2client/oauth2client'\nimport { Credentials } from '../oauth2client/models'\nimport { Captcha, CaptchaOptions } from '../captcha/captcha'\nimport { deepClone } from '../utils'\nimport MyURLSearchParams from '../utils/urlSearchParams'\nimport { SDKAdapterInterface } from '@cloudbase/adapter-interface'\nimport { ICloudbaseConfig } from '@cloudbase/types'\nimport { AuthError } from './auth-error'\n\ndeclare const wx: any\n\nasync function getEncryptUtils(isEncrypt, adapter: SDKAdapterInterface) {\n  const getUtils = async () => {\n    try {\n      /* eslint-disable */\n      // @ts-ignore\n      const utils = require('../utils/encrypt')\n      /* eslint-enable */\n      return utils\n    } catch (error) {\n      try {\n        // @ts-ignore\n        const utils = await import('../utils/encrypt')\n        return utils\n      } catch (error) {\n        return\n      }\n    }\n  }\n\n  try {\n    if ((adapter?.root?.globalThis || globalThis).IS_MP_BUILD) {\n      return\n    }\n\n    if (!process.env.IS_MP_BUILD && isEncrypt) {\n      return getUtils()\n    }\n  } catch (error) {\n    if (isEncrypt) {\n      return getUtils()\n    }\n  }\n}\n\nexport interface AuthOptions {\n  apiOrigin: string\n  apiPath?: string\n  clientId: string\n  /**\n   * basic auth\n   */\n  clientSecret?: string\n  credentialsClient?: OAuth2Client\n  request?: RequestFunction\n  baseRequest?: RequestFunction\n  storage?: SimpleStorage\n  anonymousSignInFunc?: (Credentials) => Promise<Credentials | void>\n  captchaOptions?: Partial<CaptchaOptions>\n  env?: string\n  wxCloud?: any\n  adapter?: SDKAdapterInterface\n  onCredentialsError?: (data: { msg: string; eventType?: 'credentials_error' }) => void\n  headers?: { [key: string]: string }\n  i18n?: ICloudbaseConfig['i18n']\n  useWxCloud?: boolean\n  eventBus?: any\n  /**\n   * Set to true if you want to automatically detect OAuth grants in the URL\n   * and exchange the code for credentials.\n   */\n  detectSessionInUrl?: boolean\n  /**\n   * Enable debug logging\n   */\n  debug?: boolean\n  auth?: ICloudbaseConfig['auth']\n}\n\n/**\n * Auth\n */\nexport class Auth {\n  private static parseParamsToSearch(params: any): string {\n    Object.keys(params).forEach((key) => {\n      if (!params[key]) {\n        delete params[key]\n      }\n    })\n    const searchParams = new MyURLSearchParams(params as any)\n    return searchParams.toString()\n  }\n\n  private config: AuthOptions\n  private getCustomSignTicketFn?: GetCustomSignTicketFn\n\n  /**\n   * constructor\n   * @param {AuthOptions} opts\n   */\n  constructor(opts: AuthOptions) {\n    let { request } = opts\n    let oAuth2Client = opts.credentialsClient\n    if (!oAuth2Client) {\n      const initOptions = {\n        apiOrigin: opts.apiOrigin,\n        apiPath: opts.apiPath,\n        clientId: opts.clientId,\n        storage: opts.storage,\n        env: opts.env,\n        baseRequest: opts.baseRequest /* || opts.request */, // opts.request 废弃不用来表示 oauth rquest\n        anonymousSignInFunc: opts.anonymousSignInFunc,\n        wxCloud: opts.wxCloud,\n        onCredentialsError: opts.onCredentialsError,\n        headers: opts.headers || {},\n        i18n: opts.i18n,\n        debug: opts.debug,\n      }\n      oAuth2Client = new OAuth2Client(initOptions)\n    }\n    if (!request) {\n      const baseRequest = oAuth2Client.request.bind(oAuth2Client)\n      const captcha = new Captcha({\n        env: opts.env,\n        clientId: opts.clientId,\n        request: baseRequest,\n        storage: opts.storage,\n        adapter: opts.adapter,\n        oauthInstance: this,\n        ...opts.captchaOptions,\n      })\n      request = captcha.request.bind(captcha)\n    }\n    this.config = {\n      env: opts.env,\n      apiOrigin: opts.apiOrigin,\n      apiPath: opts.apiPath,\n      clientId: opts.clientId,\n      request,\n      credentialsClient: oAuth2Client,\n      storage: opts.storage || defaultStorage,\n      adapter: opts.adapter,\n    }\n  }\n\n  /**\n   * 根据版本标识，处理待请求的url和params\n   * @param params\n   * @param key\n   * @returns\n   */\n  public getParamsByVersion(params: any, key: string) {\n    const paramsTemp = deepClone(params)\n    const url = { v2: ApiUrlsV2 }[paramsTemp?.version]?.[key] || ApiUrls[key]\n\n    if (paramsTemp) {\n      delete paramsTemp.version\n    }\n\n    return { params: paramsTemp, url }\n  }\n\n  /**\n   * Sign in.\n   * @param {SignInRequest} params A SignInRequest Object.\n   * @return {Promise<Credentials>} A Promise<Credentials> object.\n   */\n  public async signIn(params: SignInRequest): Promise<Credentials> {\n    const version = params.version || 'v1'\n    const res = this.getParamsByVersion(params, 'AUTH_SIGN_IN_URL')\n    if (res.params.query) {\n      delete res.params.query\n    }\n\n    const body = await this.getEncryptParams(res.params)\n    const credentials: Credentials = await this.config.request<Credentials>(res.url, {\n      method: 'POST',\n      body,\n    })\n    await this.config.credentialsClient.setCredentials({\n      ...credentials,\n      version,\n    })\n    return Promise.resolve(credentials)\n  }\n\n  /**\n   * Sign in Anonymously\n   * @return {Promise<Credentials>} A Promise<Credentials> object.\n   */\n  public async signInAnonymously(\n    data: {\n      provider_token?: string\n    } = {},\n    useWxCloud = false,\n  ): Promise<Credentials> {\n    const credentials: Credentials = await this.config.request<Credentials>(ApiUrls.AUTH_SIGN_IN_ANONYMOUSLY_URL, {\n      method: 'POST',\n      body: data,\n      useWxCloud,\n    })\n    await this.config.credentialsClient.setCredentials(credentials)\n    return Promise.resolve(credentials)\n  }\n\n  /**\n   * Sign up.\n   * @param {SignUpRequest} params A SignUpRequest Object.\n   * @return {Promise<Credentials>} A Promise<Credentials> object.\n   */\n  public async signUp(params: SignUpRequest): Promise<Credentials> {\n    const data: Credentials = await this.config.request<Credentials>(ApiUrls.AUTH_SIGN_UP_URL, {\n      method: 'POST',\n      body: params,\n    })\n    await this.config.credentialsClient.setCredentials(data)\n    return Promise.resolve(data)\n  }\n\n  /**\n   * Sign out.\n   * @return {Object} A Promise<SignoutRequest> object.\n   */\n  public async signOut(params?: SignoutRequest): Promise<SignoutResponse> {\n    let resp: SignoutResponse = {}\n    if (params) {\n      try {\n        resp = await this.config.request<SignoutResponse>(ApiUrls.AUTH_SIGNOUT_URL, {\n          method: 'POST',\n          withCredentials: true,\n          body: params,\n        })\n      } catch (err) {\n        if (err.error !== ErrorType.UNAUTHENTICATED) {\n          console.log('sign_out_error', err)\n        }\n      }\n      await this.config.credentialsClient.setCredentials()\n      return resp\n    }\n    const accessToken: string = await this.config.credentialsClient.getAccessToken()\n    const data = await this.config.request(ApiUrls.AUTH_REVOKE_URL, {\n      method: 'POST',\n      body: {\n        token: accessToken,\n      },\n    })\n    await this.config.credentialsClient.setCredentials()\n    return Promise.resolve(data)\n  }\n\n  /**\n   * Revoke All Devices\n   * @return {Object} A Promise<void> object.\n   */\n  public async revokeAllDevices(): Promise<void> {\n    await this.config.request<void>(ApiUrls.AUTH_REVOKE_ALL_URL, {\n      method: 'DELETE',\n      withCredentials: true,\n    })\n  }\n\n  /**\n   * Revoke Device\n   * @return {Object} A Promise<void> object.\n   */\n  public async revokeDevice(params: RevokeDeviceRequest): Promise<void> {\n    await this.config.request<void>(ApiUrls.AUTHORIZED_DEVICES_DELETE_URL + params.device_id, {\n      method: 'DELETE',\n      withCredentials: true,\n    })\n  }\n\n  /**\n   * Get the verification.\n   * @param {GetVerificationRequest} params A GetVerificationRequest Object.\n   * @return {Promise<GetVerificationResponse>} A Promise<GetVerificationResponse> object.\n   */\n  public async getVerification(\n    params: GetVerificationRequest,\n    options?: { withCaptcha: boolean },\n  ): Promise<GetVerificationResponse> {\n    let withCredentials = false\n    // 发送短信时，如果时给当前用户发，则需要带上鉴权信息\n    if (params.target === 'CUR_USER') {\n      withCredentials = true\n    } else {\n      const hasLogin = await this.hasLoginState()\n      if (hasLogin) {\n        withCredentials = true\n      }\n    }\n\n    const body = deepClone(params)\n\n    if (body.phone_number && !/^\\+\\d{1,3}\\s+\\d+/.test(body.phone_number)) {\n      body.phone_number = `+86 ${body.phone_number}`\n    }\n\n    return this.config.request<GetVerificationResponse>(ApiUrls.VERIFICATION_URL, {\n      method: 'POST',\n      body,\n      withCaptcha: options?.withCaptcha || false,\n      withCredentials,\n    })\n  }\n\n  /**\n   *  Verify the code\n   * @param {VerifyRequest} params A VerifyRequest Object.\n   * @return {Promise<VerifyResponse>} A Promise<VerifyResponse> object.\n   */\n  public async verify(params: VerifyRequest): Promise<VerifyResponse> {\n    const res = this.getParamsByVersion(params, 'VERIFY_URL')\n    const data = await this.config.request<VerifyResponse>(res.url, {\n      method: 'POST',\n      body: res.params,\n    })\n\n    if (params?.version === 'v2') {\n      await this.config.credentialsClient.setCredentials({\n        ...data,\n        version: 'v2',\n      })\n    }\n\n    return data\n  }\n\n  /**\n   * Gen provider redirect uri.\n   * @param {GenProviderRedirectUriRequest} params A GenProviderRedirectUriRequest object.\n   * @return {Promise<GenProviderRedirectUriResponse>} A Promise<GenProviderRedirectUriResponse> object.\n   */\n  public async genProviderRedirectUri(params: GenProviderRedirectUriRequest): Promise<GenProviderRedirectUriResponse> {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    const { provider_redirect_uri: redirect_uri, other_params: otherParams = {}, ...restParams } = params\n    if (redirect_uri && !restParams.redirect_uri) {\n      restParams.redirect_uri = redirect_uri\n    }\n\n    let url = `${ApiUrls.PROVIDER_URI_URL}?${Auth.parseParamsToSearch(restParams)}`\n    Object.keys(otherParams).forEach((key) => {\n      const value = otherParams[key]\n      if (key === 'sign_out_uri' && !(value?.length > 0)) {\n        return\n      }\n      url += `&other_params[${key}]=${encodeURIComponent(value)}`\n    })\n\n    return this.config.request<GenProviderRedirectUriResponse>(url, {\n      method: 'GET',\n    })\n  }\n\n  /**\n   * Grant provider token.\n   * @param {GrantProviderTokenRequest} params A GrantProviderTokenRequest object.\n   * @return {Promise<GrantProviderTokenResponse>} A Promise<GrantProviderTokenResponse> object.\n   */\n  public async grantProviderToken(\n    params: GrantProviderTokenRequest,\n    useWxCloud = false,\n  ): Promise<GrantProviderTokenResponse> {\n    return this.config.request<GrantProviderTokenResponse>(ApiUrls.PROVIDER_TOKEN_URL, {\n      method: 'POST',\n      body: params,\n      useWxCloud,\n    })\n  }\n\n  /**\n   * Grant provider token.\n   * @param {PatchProviderTokenRequest} params A PatchProviderTokenRequest object.\n   * @return {Promise<PatchProviderTokenResponse>} A Promise<PatchProviderTokenResponse> object.\n   */\n  public async patchProviderToken(params: PatchProviderTokenRequest): Promise<PatchProviderTokenResponse> {\n    return this.config.request<PatchProviderTokenResponse>(ApiUrls.PROVIDER_TOKEN_URL, {\n      method: 'PATCH',\n      body: params,\n    })\n  }\n\n  /**\n   * Signin with provider request.\n   * @param {SignInWithProviderRequest} params A SignInWithProviderRequest object.\n   * @return {Promise<Credentials>} A Promise<Credentials> object.\n   */\n  public async signInWithProvider(params: SignInWithProviderRequest, useWxCloud = false): Promise<Credentials> {\n    const res = this.getParamsByVersion(params, 'AUTH_SIGN_IN_WITH_PROVIDER_URL')\n\n    const credentials: Credentials = await this.config.request<Credentials>(res.url, {\n      method: 'POST',\n      body: res.params,\n      useWxCloud,\n    })\n\n    await this.config.credentialsClient.setCredentials({\n      ...credentials,\n      version: params?.version || 'v1',\n    })\n    return Promise.resolve(credentials)\n  }\n\n  public async toBindIdentity(params: {\n    provider_token: string\n    provider: string\n    credentials?: Credentials\n    fireEvent?: boolean\n  }) {\n    const credentials = params.credentials || (await this.config.credentialsClient.localCredentials.getCredentials())\n    let res: any\n    try {\n      await this.bindWithProvider(\n        {\n          provider_token: params.provider_token,\n        },\n        credentials,\n      )\n      res = { data: { type: OAUTH_TYPE.BIND_IDENTITY, provider: params.provider }, error: null }\n    } catch (error) {\n      res = { data: { type: OAUTH_TYPE.BIND_IDENTITY }, error: new AuthError(error) }\n    }\n\n    if (params.fireEvent) {\n      this.config.eventBus?.fire?.(EVENTS.AUTH_STATE_CHANGED, {\n        event: AUTH_STATE_CHANGED_TYPE.BIND_IDENTITY,\n        info: res,\n      })\n    }\n\n    return res\n  }\n\n  /**\n   * 获取初始 session（如从 URL 中的 OAuth 回调）。\n   * 用于 OAuth2Client.initialize() 回调。\n   * 内部处理 URL 检测、OAuth 验证，返回 credentials 和 user。\n   * 不调用 setCredentials，由 OAuth2Client 负责保存。\n   *\n   * @returns { data: { session: Credentials; user?: any } | null, error: Error | null }\n   */\n  public async getInitialSession(): Promise<{\n    data: { session: Credentials; user?: any } | null\n    error: Error | null\n  }> {\n    let data: any = {}\n    try {\n      // Check if running in browser\n      if (typeof window === 'undefined' || typeof document === 'undefined') {\n        return { data: null, error: null }\n      }\n\n      // Parse URL parameters\n      const localSearch = new URLSearchParams(location?.search)\n      const code = localSearch.get('code')\n      const state = localSearch.get('state')\n\n      // No OAuth callback detected\n      if (!code || !state) {\n        return { data: null, error: null }\n      }\n\n      // Get provider from sessionStorage (saved during signInWithOAuth)\n      let cacheData: {\n        provider?: string\n        search?: string\n        hash?: string\n        type?: (typeof OAUTH_TYPE)[keyof typeof OAUTH_TYPE]\n      } | null = null\n      try {\n        cacheData = JSON.parse(sessionStorage.getItem(state) || 'null')\n      } catch {\n        // ignore\n      }\n      data = { type: cacheData?.type }\n      // Check for error in URL\n      const errorParam = localSearch.get('error')\n      const errorDescription = localSearch.get('error_description')\n      if (errorParam || errorDescription) {\n        return {\n          data,\n          error: new AuthError({ message: errorDescription || errorParam || 'Unknown error from OAuth provider' }),\n        }\n      }\n\n      const provider = cacheData?.provider || localSearch.get('provider')\n\n      if (!provider) {\n        return { data, error: new AuthError({ message: 'Provider is required for OAuth verification' }) }\n      }\n\n      // 获取当前页面的 redirect_uri\n      const redirectUri = location.origin + location.pathname\n\n      // Step 1: 获取 provider token\n      const { provider_token: providerToken } = await this.grantProviderToken({\n        provider_id: provider,\n        provider_redirect_uri: redirectUri,\n        provider_code: code,\n      })\n\n      let credentials: Credentials\n      let user: any = null\n      let res: any\n\n      if (cacheData.type === OAUTH_TYPE.BIND_IDENTITY) {\n        credentials = await this.config.credentialsClient.localCredentials.getCredentials()\n        res = await this.toBindIdentity({ provider, provider_token: providerToken, credentials })\n      } else if (cacheData.type === OAUTH_TYPE.SIGN_IN) {\n        res = this.getParamsByVersion({ provider }, 'AUTH_SIGN_IN_WITH_PROVIDER_URL')\n\n        // Step 2: 用 provider token 换取 credentials（直接调用 API，不触发 setCredentials）\n        credentials = await this.config.request<Credentials>(res.url, {\n          method: 'POST',\n          body: { provider_token: providerToken },\n        })\n\n        // Step 3: 获取 user info，传入 getCredentials 函数避免死锁\n        // 不调用 setCredentials，由 OAuth2Client._initialize 负责保存\n        try {\n          user = await this.getUserInfo({ credentials })\n        } catch (e) {\n          console.error('get user info error', e)\n          // 获取 user 失败不影响登录流程\n        }\n\n        res = { data: { ...data, session: credentials, user }, error: null }\n      }\n\n      // Clean up URL parameters and restore original URL state\n      localSearch.delete('code')\n      localSearch.delete('state')\n      localSearch.delete('provider')\n      this.restoreUrlState(\n        cacheData?.search === undefined ? `?${localSearch.toString()}` : cacheData.search,\n        cacheData?.hash || location.hash,\n      )\n\n      // Remove session storage\n      try {\n        sessionStorage.removeItem(state)\n      } catch {\n        // ignore\n      }\n\n      return res\n    } catch (error) {\n      return { data, error: new AuthError(error) }\n    }\n  }\n\n  /**\n   * Signin with custom.\n   * @param {SignInCustomRequest} params A SignInCustomRequest object.\n   * @return {Promise<Credentials>} A Promise<Credentials> object.\n   */\n  public async signInCustom(params: SignInCustomRequest): Promise<Credentials> {\n    const credentials: Credentials = await this.config.request<Credentials>(ApiUrls.AUTH_SIGN_IN_CUSTOM, {\n      method: 'POST',\n      body: params,\n    })\n\n    await this.config.credentialsClient.setCredentials(credentials)\n    return Promise.resolve(credentials)\n  }\n\n  /**\n   * sign in with wechat idendify\n   * 需要结合 http overcallFunction 使用\n   */\n  public async signInWithWechat(params: any = {}): Promise<Credentials> {\n    const credentials: Credentials = await this.config.request<Credentials>(ApiUrls.AUTH_SIGN_IN_WITH_WECHAT_URL, {\n      method: 'POST',\n      body: params,\n    })\n    await this.config.credentialsClient.setCredentials(credentials)\n    return Promise.resolve(credentials)\n  }\n\n  /**\n   * Bind with provider\n   * @param {BindWithProviderRequest} params A BindWithProviderRequest object.\n   * @return {Promise<void>} A Promise<any> object.\n   */\n  public async bindWithProvider(params: BindWithProviderRequest, credentials?: Credentials): Promise<void> {\n    return this.config.request<any>(ApiUrls.PROVIDER_BIND_URL, {\n      method: 'POST',\n      body: params,\n      withCredentials: true,\n      getCredentials: credentials ? () => credentials : undefined,\n    })\n  }\n\n  /**\n   * Get the user profile.\n   * @return {Promise<UserProfile>} A Promise<UserProfile> object.\n   */\n  public async getUserProfile(params: { version?: string }): Promise<UserProfile> {\n    return this.getUserInfo(params)\n  }\n\n  /**\n   * Get the user info.\n   * @param params.getCredentials Optional custom getCredentials function to bypass default getCredentials() and avoid deadlock\n   * @return {Promise<UserInfo>} A Promise<UserProfile> object.\n   */\n  public async getUserInfo(params: {\n    version?: string\n    query?: string\n    credentials?: Credentials\n  } = {},): Promise<UserInfo> {\n    const res = this.getParamsByVersion(params, 'USER_ME_URL')\n\n    if (res.params?.query) {\n      const searchParams = new MyURLSearchParams(res.params.query as any)\n      res.url += `?${searchParams.toString()}`\n    }\n\n    const userInfo = await this.config.request<UserInfo>(res.url, {\n      method: 'GET',\n      withCredentials: true,\n      getCredentials: params.credentials ? () => params.credentials : undefined,\n    })\n\n    if (userInfo.sub) {\n      userInfo.uid = userInfo.sub\n    }\n\n    // 优先从 providers 中找到当前小程序 appId 对应的 provider_user_id 作为 open_id\n    if (userInfo.providers?.length) {\n      try {\n        if (typeof wx !== 'undefined' && wx.getAccountInfoSync) {\n          const wxAppId = wx.getAccountInfoSync().miniProgram?.appId\n          const matched = userInfo.providers.find(p => p.id === wxAppId)\n          if (matched?.provider_user_id) {\n            userInfo.open_id = matched.provider_user_id\n          }\n        }\n      } catch (e) {}\n    }\n\n    return userInfo\n  }\n\n  /**\n   * Get the user info by weda plugin.\n   * @return {Promise<any>} A Promise<any> object.\n   */\n  public async getWedaUserInfo(): Promise<any> {\n    const userInfo = await this.config.request<any>(ApiUrls.WEDA_USER_URL, {\n      method: 'GET',\n      withCredentials: true,\n    })\n    return userInfo\n  }\n\n  /**\n   * Delete me\n   * @param params\n   */\n  public async deleteMe(params: WithSudoRequest): Promise<UserProfile> {\n    const res = this.getParamsByVersion(params, 'USER_ME_URL')\n    const url = `${res.url}?${Auth.parseParamsToSearch(res.params)}`\n    return this.config.request<UserProfile>(url, {\n      method: 'DELETE',\n      withCredentials: true,\n    })\n  }\n\n  /**\n   * hasLoginState check if has login state\n   * @return {Promise<boolean>} A Promise<boolean> object.\n   */\n  public async hasLoginState(): Promise<boolean> {\n    try {\n      await this.config.credentialsClient.getAccessToken()\n      return true\n    } catch (error) {\n      return false\n    }\n  }\n\n  public hasLoginStateSync(): Credentials | null {\n    const credentials = this.config.credentialsClient.getCredentialsSync()\n    return credentials\n  }\n\n  public async getLoginState(): Promise<Credentials | null> {\n    return this.config.credentialsClient.getCredentialsAsync()\n  }\n\n  /**\n   * Trans by provider.\n   * @param {TransByProviderRequest} params A TransByProviderRequest object.\n   * @return {Promise<Credentials>} A Promise<Credentials> object.\n   */\n  public async transByProvider(params: TransByProviderRequest): Promise<Credentials> {\n    return this.config.request<Credentials>(ApiUrls.USER_TRANS_BY_PROVIDER_URL, {\n      method: 'PATCH',\n      body: params,\n      withCredentials: true,\n    })\n  }\n\n  /**\n   * Grant token.\n   * @param {GrantTokenRequest} params A GrantTokenRequest object.\n   * @return {Promise<Credentials>} A Promise<Credentials> object.\n   */\n  public async grantToken(params: GrantTokenRequest): Promise<Credentials> {\n    const res = this.getParamsByVersion(params, 'AUTH_TOKEN_URL')\n    return this.config.request<Credentials>(res.url, {\n      method: 'POST',\n      body: res.params,\n    })\n  }\n\n  /**\n   * Get the provide list.\n   * @return {Promise<ProvidersResponse>} A Promise<ProvidersResponse> object.\n   */\n  public async getProviders(): Promise<ProvidersResponse> {\n    return this.config.request<ProvidersResponse>(ApiUrls.PROVIDER_LIST, {\n      method: 'GET',\n      withCredentials: true,\n    })\n  }\n\n  /**\n   * unbind provider.\n   * @param {UnbindProviderRequest} params\n   * @return {Promise<any>}\n   */\n  public async unbindProvider(params: UnbindProviderRequest): Promise<void> {\n    return this.config.request<any>(`${ApiUrls.PROVIDER_UNBIND_URL}/${params.provider_id}`, {\n      method: 'DELETE',\n      withCredentials: true,\n    })\n  }\n\n  /**\n   * check Password.\n   * @param {CheckPasswordRequest} params\n   * @return {Promise<any>}\n   */\n  public async checkPassword(params: CheckPasswordRequest): Promise<void> {\n    return this.config.request<any>(`${ApiUrls.CHECK_PWD_URL}`, {\n      method: 'POST',\n      withCredentials: true,\n      body: params,\n    })\n  }\n\n  /**\n   * Edit Contact 修改 手机号 或 邮箱\n   * @param {EditContactRequest} params\n   * @return {Promise<void>}\n   */\n  public async editContact(params: EditContactRequest): Promise<void> {\n    return this.config.request<void>(`${ApiUrls.BIND_CONTACT_URL}`, {\n      method: 'PATCH',\n      withCredentials: true,\n      body: params,\n    })\n  }\n\n  /**\n   * Set Password.\n   * @param {SetPasswordrRequest} params\n   * @return {Promise<any>}\n   */\n  public async setPassword(params: SetPasswordRequest): Promise<void> {\n    return this.config.request<any>(`${ApiUrls.AUTH_SET_PASSWORD}`, {\n      method: 'PATCH',\n      withCredentials: true,\n      body: params,\n    })\n  }\n\n  /**\n   * updatePasswordByOld 使用旧密码修改密码，如果已经绑定手机号，请先：sudo，再修改密码\n   * @param {SetPasswordrRequest} params\n   * @return {Promise<any>}\n   */\n  public async updatePasswordByOld(params: UpdatePasswordRequest): Promise<void> {\n    const sudoToken = await this.sudo({ password: params.old_password })\n    return this.setPassword({\n      sudo_token: sudoToken.sudo_token,\n      new_password: params.new_password,\n    })\n  }\n\n  /**\n   * sudo\n   * @param {sudo} params\n   * @return {Promise<any>}\n   */\n  public async sudo(params: SudoRequest): Promise<SudoResponse> {\n    return this.config.request<SudoResponse>(`${ApiUrls.SUDO_URL}`, {\n      method: 'POST',\n      withCredentials: true,\n      body: params,\n    })\n  }\n\n  /**\n   * Get the current user verification.\n   * @param {GetVerificationRequest} params A GetVerificationRequest Object.\n   * @return {Promise<GetVerificationResponse>} A Promise<GetVerificationResponse> object.\n   */\n  public async sendVerificationCodeToCurrentUser(params: GetVerificationRequest): Promise<GetVerificationResponse> {\n    params.target = 'CUR_USER'\n    return this.config.request<GetVerificationResponse>(ApiUrls.VERIFICATION_URL, {\n      method: 'POST',\n      body: params,\n      withCredentials: true,\n      withCaptcha: true,\n    })\n  }\n\n  /**\n   * change Bound provider.\n   * @param {ChangeBoundProviderRequest} params A GetVerificationRequest Object.\n   * @return {Promise<ChangeBoundProviderResponse>} A Promise<GetVerificationResponse> object.\n   */\n  public async changeBoundProvider(params: ChangeBoundProviderRequest): Promise<ChangeBoundProviderResponse> {\n    return this.config.request<ChangeBoundProviderResponse>(`${ApiUrls.PROVIDER_LIST}/${params.provider_id}/trans`, {\n      method: 'POST',\n      body: {\n        provider_trans_token: params.trans_token,\n      },\n      withCredentials: true,\n    })\n  }\n\n  /**\n   * Patch the user profile. 没有和数据源同步\n   * @deprecated use updateUserBasicInfo\n   * @param {UserProfile} params A UserProfile Object.\n   * @return {Promise<UserProfile>} A Promise<UserProfile> object.\n   */\n  public async setUserProfile(params: UserProfile): Promise<UserProfile> {\n    return this.config.request<UserProfile>(ApiUrls.USER_PRIFILE_URL, {\n      method: 'PATCH',\n      body: params,\n      withCredentials: true,\n    })\n  }\n\n  /**\n   * Update user basic info\n   * @return {Promise<void>}\n   */\n  public async updateUserBasicInfo(params: ModifyUserBasicInfoRequest): Promise<void> {\n    return this.config.request(ApiUrls.USER_BASIC_EDIT_URL, {\n      method: 'POST',\n      withCredentials: true,\n      body: params,\n    })\n  }\n\n  /**\n   * Patch the user profile.\n   * @param {QueryUserProfileReq} appended_params A QueryUserProfileReq Object.\n   * @return {Promise<UserProfile>} A Promise<UserProfile> object.\n   */\n  public async queryUserProfile(params: QueryUserProfileRequest): Promise<QueryUserProfileResponse> {\n    // let url = new URL(ApiUrls.USER_QUERY_URL);\n    const searchParams = new MyURLSearchParams(params as any)\n    // url.search = searchParams.toString();\n    return this.config.request<QueryUserProfileResponse>(`${ApiUrls.USER_QUERY_URL}?${searchParams.toString()}`, {\n      method: 'GET',\n      withCredentials: true,\n    })\n  }\n\n  /**\n   * setCustomSignFunc set the get ticket function\n   * @param getTickFn\n   */\n  public setCustomSignFunc(getTickFn: GetCustomSignTicketFn) {\n    this.getCustomSignTicketFn = getTickFn\n  }\n\n  /**\n   * SignInWithCustomTicket custom signIn\n   * @constructor\n   */\n  // public async signInWithCustomTicket(params?: { version?: string }): Promise<Credentials> {\n  //   const customSignTicketFn = this.getCustomSignTicketFn\n  //   if (!customSignTicketFn) {\n  //     return Promise.reject({\n  //     })\n  //   }\n  //   const customTicket = await customSignTicketFn()\n  //   return this.signInWithProvider({\n  //     ...params,\n  //     provider_id: 'custom',\n  //     provider_token: customTicket,\n  //   })\n  // }\n  public async signInWithCustomTicket(): Promise<Credentials> {\n    const customSignTicketFn = this.getCustomSignTicketFn\n    if (!customSignTicketFn) {\n      return Promise.reject({\n        error: 'failed_precondition',\n        error_description: 'please use setCustomSignFunc to set custom sign function',\n      })\n    }\n    const customTicket = await customSignTicketFn()\n    return this.signInCustom({\n      provider_id: 'custom',\n      ticket: customTicket,\n    })\n  }\n\n  /**\n   * Reset password\n   * @param {ResetPasswordRequest} params\n   * @returns {Promise<void>}\n   * @memberof Auth\n   */\n  public async resetPassword(params: ResetPasswordRequest): Promise<void> {\n    return this.config.request(ApiUrls.AUTH_RESET_PASSWORD, {\n      method: 'POST',\n      body: params,\n      // withCredentials: true\n    })\n  }\n\n  /**\n   * Authorize oauth Authorize\n   * @param params\n   * @constructor\n   */\n  public async authorize(params: AuthorizeRequest): Promise<AuthorizeResponse> {\n    return this.config.request<AuthorizeResponse>(ApiUrls.AUTHORIZE_URL, {\n      method: 'POST',\n      withCredentials: true,\n      body: params,\n    })\n  }\n\n  /**\n   * authorize device\n   * @param params\n   */\n  public async authorizeDevice(params: AuthorizeDeviceRequest): Promise<void> {\n    return this.config.request<void>(ApiUrls.AUTHORIZE_DEVICE_URL, {\n      method: 'POST',\n      withCredentials: true,\n      body: params,\n    })\n  }\n\n  /**\n   * device authorization\n   * @param {DeviceAuthorizeRequest} params\n   * @returns {Promise<DeviceAuthorizeResponse>}\n   * @memberof Auth\n   */\n  public async deviceAuthorize(params: DeviceAuthorizeRequest): Promise<DeviceAuthorizeResponse> {\n    return this.config.request(ApiUrls.AUTH_GET_DEVICE_CODE, {\n      method: 'POST',\n      body: params,\n    })\n  }\n\n  /**\n   * OAuth get authorize info\n   * @param params\n   * @constructor\n   */\n  public async authorizeInfo(params: AuthorizeInfoRequest): Promise<AuthorizeInfoResponse> {\n    const url = `${ApiUrls.AUTHORIZE_INFO_URL}?${Auth.parseParamsToSearch(params)}`\n    let withBasicAuth = true\n    let withCredentials = false\n    const hasLogin = await this.hasLoginState()\n    if (hasLogin) {\n      withCredentials = true\n      withBasicAuth = false\n    }\n    return this.config.request<AuthorizeInfoResponse>(url, {\n      method: 'GET',\n      withBasicAuth,\n      withCredentials,\n    })\n  }\n\n  public async checkUsername(params: CheckUsernameRequest): Promise<void> {\n    return this.config.request(ApiUrls.CHECK_USERNAME, {\n      method: 'GET',\n      body: params,\n      withCredentials: true,\n    })\n  }\n\n  public async checkIfUserExist(params: CheckIfUserExistRequest): Promise<CheckIfUserExistResponse> {\n    const searchParams = new MyURLSearchParams(params as any)\n\n    return this.config.request<CheckIfUserExistResponse>(`${ApiUrls.CHECK_IF_USER_EXIST}?${searchParams.toString()}`, {\n      method: 'GET',\n    })\n  }\n\n  public async loginScope(): Promise<string> {\n    return this.config.credentialsClient.getScope()\n  }\n\n  public async loginGroups(): Promise<string[]> {\n    return this.config.credentialsClient.getGroups()\n  }\n\n  public async refreshTokenForce(params: { version?: string }) {\n    const credentials: Credentials = await this.config.credentialsClient.getCredentials()\n    return await this.config.credentialsClient.refreshToken({\n      ...credentials,\n      version: params?.version || 'v1',\n    })\n  }\n\n  public async getCredentials() {\n    return this.config.credentialsClient.getCredentials()\n  }\n\n  /**\n   * get public key for request params encryption\n   * @returns\n   */\n  public async getPublicKey(): Promise<PublicKey> {\n    return this.config.request<PublicKey>(ApiUrlsV2.AUTH_PUBLIC_KEY, {\n      method: 'POST',\n      body: {},\n    })\n  }\n\n  /**\n   * encrypt request params\n   * @param params\n   * @returns\n   */\n  public async getEncryptParams(params: Record<any, any>): Promise<EncryptParams> {\n    const { isEncrypt } = params\n    delete params.isEncrypt\n\n    const payload = deepClone(params)\n\n    const encryptUtils = await getEncryptUtils(isEncrypt, this.config.adapter)\n\n    if (!encryptUtils) {\n      return params\n    }\n\n    let publicKey = ''\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    let public_key_thumbprint = ''\n\n    try {\n      const res = await this.getPublicKey()\n      publicKey = res.public_key\n      public_key_thumbprint = res.public_key_thumbprint\n\n      if (!publicKey || !public_key_thumbprint) {\n        throw res\n      }\n    } catch (error) {\n      throw error\n    }\n    return {\n      params: encryptUtils.getEncryptInfo({ publicKey, payload }),\n      public_key_thumbprint,\n    }\n  }\n\n  /**\n   * get provider sub type\n   * @returns\n   */\n  public async getProviderSubType(): Promise<ProviderSubType> {\n    return this.config.request<ProviderSubType>(ApiUrls.GET_PROVIDER_TYPE, {\n      method: 'POST',\n      body: {\n        provider_id: 'weda',\n      },\n    })\n  }\n\n  /**\n   * get provider sub type\n   * @returns\n   */\n  public async verifyCaptchaData({ token, key }: { token: string; key: string }) {\n    return this.config.request<{ captcha_token: string; expires_in: number }>(ApiUrls.VERIFY_CAPTCHA_DATA_URL, {\n      method: 'POST',\n      body: { token, key },\n      withCredentials: false,\n    })\n  }\n\n  public async createCaptchaData({ state, redirect_uri = undefined }) {\n    return this.config.request<{ token: string; data: string }>(ApiUrls.CAPTCHA_DATA_URL, {\n      method: 'POST',\n      body: { state, redirect_uri },\n      withCredentials: false,\n    })\n  }\n\n  /**\n   * mini-program scan code\n   * @returns\n   */\n  public async getMiniProgramCode(params: GetMiniProgramQrCodeRequest): Promise<GetMiniProgramQrCodeResponse> {\n    return this.config.request<GetMiniProgramQrCodeResponse>(ApiUrls.GET_MINIPROGRAM_QRCODE, {\n      method: 'POST',\n      body: params,\n    })\n  }\n\n  /**\n   * mini-program scan code status\n   * @returns\n   */\n  public async getMiniProgramQrCodeStatus(params: GetMiniProgramQrCodeStatusRequest,): Promise<GetMiniProgramQrCodeStatusResponse> {\n    return this.config.request<GetMiniProgramQrCodeStatusResponse>(ApiUrls.GET_MINIPROGRAM_QRCODE_STATUS, {\n      method: 'POST',\n      body: params,\n    })\n  }\n\n  /**\n   * get user behavior log\n   * @param params\n   */\n  public async getUserBehaviorLog(params: GetUserBehaviorLog): Promise<GetUserBehaviorLogRes> {\n    const action = { LOGIN: 'query[action]=USER_LOGIN', MODIFY: 'ne_query[action]=USER_LOGIN' }\n    const url = `${ApiUrls.GET_USER_BEHAVIOR_LOG}?${action[params.type]}&limit=${params.limit}${\n      params.page_token ? `&page_token=${params.page_token}` : ''\n    }`\n    return this.config.request(url, {\n      method: 'GET',\n      withCredentials: true,\n    })\n  }\n\n  /**\n   * 这个方法是用户自己修改自己的密码，不同于/auth/v1/user/password接口，该接口是管理员修改个人的\n   * @param {ModifyUserBasicInfoRequest} params A ModifyUserBasicInfoRequest Object.\n   * @return {Promise<void>} A Promise<void> object.\n   */\n  public async modifyPassword(params: ModifyUserBasicInfoRequest): Promise<void> {\n    let publicKey = ''\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    let public_key_thumbprint = ''\n\n    const encryptUtils = await getEncryptUtils(true, this.config.adapter)\n\n    if (!encryptUtils) {\n      throw new Error('do not support encrypt, a encrypt util required.')\n    }\n\n    try {\n      const res = await this.getPublicKey()\n      publicKey = res.public_key\n      public_key_thumbprint = res.public_key_thumbprint\n\n      if (!publicKey || !public_key_thumbprint) {\n        throw res\n      }\n    } catch (error) {\n      throw error\n    }\n\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    const encrypt_password = params.password ? encryptUtils.getEncryptInfo({ publicKey, payload: params.password }) : ''\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    const encrypt_new_password = encryptUtils.getEncryptInfo({ publicKey, payload: params.new_password })\n    return this.config.request(ApiUrls.USER_BASIC_EDIT_URL, {\n      method: 'POST',\n      withCredentials: true,\n      body: {\n        user_id: params.user_id,\n        encrypt_password,\n        encrypt_new_password,\n        public_key_thumbprint,\n      },\n    })\n  }\n\n  /**\n   * 重置密码，该接口无需登录就可以重置密码\n   * @param {ModifyPasswordWithoutLoginRequest} params A ModifyPasswordWithoutLoginRequest Object.\n   * @return {Promise<void>} A Promise<void> object.\n   */\n  public async modifyPasswordWithoutLogin(params: ModifyPasswordWithoutLoginRequest): Promise<void> {\n    let publicKey = ''\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    let public_key_thumbprint = ''\n\n    const encryptUtils = await getEncryptUtils(true, this.config.adapter)\n\n    if (!encryptUtils) {\n      throw new Error('do not support encrypt, a encrypt util required.')\n    }\n\n    try {\n      const res = await this.getPublicKey()\n      publicKey = res.public_key\n      public_key_thumbprint = res.public_key_thumbprint\n\n      if (!publicKey || !public_key_thumbprint) {\n        throw res\n      }\n    } catch (error) {\n      throw error\n    }\n\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    const encrypt_password = params.password ? encryptUtils.getEncryptInfo({ publicKey, payload: params.password }) : ''\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    const encrypt_new_password = encryptUtils.getEncryptInfo({ publicKey, payload: params.new_password })\n    return this.config.request(ApiUrlsV2.AUTH_RESET_PASSWORD, {\n      method: 'POST',\n      body: {\n        username: params.username,\n        password: encrypt_password,\n        new_password: encrypt_new_password,\n        public_key_thumbprint,\n      },\n    })\n  }\n\n  /**\n   * Restore URL state after OAuth callback\n   */\n  private restoreUrlState(search?: string, hash?: string): void {\n    if (search === undefined) return\n    try {\n      const url = new URL(window.location.href)\n      url.search = search\n      url.hash = hash || ''\n      window.history.replaceState(null, '', url.toString())\n      window.location.replace(url.toString())\n    } catch {\n      // ignore\n    }\n  }\n}\n"]}