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

package/node_modules/@cloudbase/app/dist/esm/constants/common.js

@@ -0,0 +1,91 @@
+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);
+};
+import { constants } from '@cloudbase/utilities';
+var setUtilitiesSdkName = constants.setSdkName, setUtilitiesProtocol = constants.setProtocol;
+var sdkVersion = '';
+var sdkName = '@cloudbase/js-sdk';
+export function setSdkVersion(version) {
+    sdkVersion = version;
+}
+export function getSdkVersion() {
+    return sdkVersion;
+}
+export function setSdkName(name) {
+    sdkName = name;
+    setUtilitiesSdkName(name);
+}
+export function getSdkName() {
+    return sdkName;
+}
+export var DATA_VERSION = '2020-01-10';
+var END_POINT_INFO_ARR = [];
+var END_POINT_INFO_SEARCH_KEYS = ['env', 'endPointKey', 'region'];
+export var DEFAULT_PROTOCOL = 'https:';
+function findMatchedInfo(info) {
+    return END_POINT_INFO_ARR.find(function (targetInfo) { return END_POINT_INFO_SEARCH_KEYS.filter(function (searchKey) { return info[searchKey] != null; }).every(function (searchKey) { return targetInfo[searchKey] === info[searchKey]; }); });
+}
+export function setEndPointInfo(newInfo) {
+    var _a, _b;
+    if (newInfo.protocol && !/:$/.test(newInfo.protocol)) {
+        newInfo.protocol = "".concat(newInfo.protocol, ":");
+    }
+    var endPointInfo = findMatchedInfo(newInfo);
+    if (endPointInfo) {
+        if (newInfo.baseUrl != null) {
+            endPointInfo.baseUrl = newInfo.baseUrl;
+        }
+        if (newInfo.protocol != null) {
+            endPointInfo.protocol = newInfo.protocol;
+        }
+    }
+    else {
+        END_POINT_INFO_ARR.push(__assign(__assign({}, newInfo), { protocol: (_a = newInfo.protocol) !== null && _a !== void 0 ? _a : DEFAULT_PROTOCOL }));
+    }
+    if (newInfo.endPointKey === 'CLOUD_API') {
+        setUtilitiesProtocol(((_b = newInfo.protocol) !== null && _b !== void 0 ? _b : DEFAULT_PROTOCOL));
+    }
+}
+export function getEndPointInfo(env, endPointKey, region) {
+    return findMatchedInfo({ env: env, endPointKey: endPointKey, region: region });
+}
+export function setGatewayEndPointWithEnv(env, protocol, init) {
+    var baseUrl = "//".concat(env, ".api.tcloudbasegateway.com/v1");
+    if (init) {
+        baseUrl = "//".concat(env, ".api.intl.tcloudbasegateway.com/v1");
+    }
+    setEndPointInfo({ endPointKey: 'GATEWAY', env: env, baseUrl: baseUrl, protocol: protocol });
+}
+export function setRegionLevelEndpoint(env, region, protocol) {
+    var baseUrl = "//".concat(env, ".").concat(region || 'ap-shanghai', ".tcb-api.tencentcloudapi.com/web");
+    setEndPointInfo({ env: env, region: region, baseUrl: baseUrl, protocol: protocol, endPointKey: 'CLOUD_API' });
+}
+export function getBaseEndPoint(env, endPointKey) {
+    if (endPointKey === void 0) { endPointKey = 'CLOUD_API'; }
+    var info = getEndPointInfo(env, endPointKey || 'CLOUD_API');
+    var PROTOCOL = info.protocol, BASE_URL = info.baseUrl;
+    var webEndpoint = "".concat(PROTOCOL).concat(BASE_URL);
+    return webEndpoint.match(/(http(s)?:)?\/\/([^/?#]*)/)[0];
+}
+export var LOGINTYPE;
+(function (LOGINTYPE) {
+    LOGINTYPE["NULL"] = "NULL";
+    LOGINTYPE["ANONYMOUS"] = "ANONYMOUS";
+    LOGINTYPE["WECHAT"] = "WECHAT";
+    LOGINTYPE["WECHAT_PUBLIC"] = "WECHAT-PUBLIC";
+    LOGINTYPE["WECHAT_OPEN"] = "WECHAT-OPEN";
+    LOGINTYPE["CUSTOM"] = "CUSTOM";
+    LOGINTYPE["EMAIL"] = "EMAIL";
+    LOGINTYPE["USERNAME"] = "USERNAME";
+    LOGINTYPE["PHONE"] = "PHONE";
+})(LOGINTYPE || (LOGINTYPE = {}));
+export var OAUTH2_LOGINTYPE_PREFIX = 'OAUTH2';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../src/constants/common.ts"],"names":[],"mappings":"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","sourcesContent":["import { EndPointKey } from '@cloudbase/types'\nimport { constants } from '@cloudbase/utilities'\n\n// @ts-ignore\nconst { setSdkName: setUtilitiesSdkName, setProtocol: setUtilitiesProtocol } = constants\n/**\n * SDK\n */\nlet sdkVersion = ''\nlet sdkName = '@cloudbase/js-sdk'\n\nexport function setSdkVersion(version: string) {\n  sdkVersion = version\n}\nexport function getSdkVersion() {\n  return sdkVersion\n}\nexport function setSdkName(name: string) {\n  sdkName = name\n  setUtilitiesSdkName(name)\n}\nexport function getSdkName() {\n  return sdkName\n}\nexport const DATA_VERSION = '2020-01-10'\n\ninterface EndPointInfo {\n  env: string\n  endPointKey: EndPointKey\n  region?: string\n  baseUrl?: string\n  protocol?: Protocol\n}\n\ntype Protocol = 'http' | 'https' | 'http:' | 'https:'\n\n/**\n *  所有 endPoint 信息\n *  避免直接操作该数组\n *  使用 setEndPointInfo、 getEndPointInfo\n */\nconst END_POINT_INFO_ARR: Array<EndPointInfo> = []\n\n/** 用来查找 endPoint 的字段 */\nconst END_POINT_INFO_SEARCH_KEYS = ['env', 'endPointKey', 'region']\n\nexport const DEFAULT_PROTOCOL: 'http:' | 'https:' = 'https:'\n\nfunction findMatchedInfo(info: EndPointInfo) {\n  // eslint-disable-next-line max-len, eqeqeq\n  return END_POINT_INFO_ARR.find(targetInfo => END_POINT_INFO_SEARCH_KEYS.filter(searchKey => info[searchKey] != null).every(searchKey => targetInfo[searchKey] === info[searchKey],),)\n}\n\nexport function setEndPointInfo(newInfo: EndPointInfo) {\n  if (newInfo.protocol && !/:$/.test(newInfo.protocol)) {\n    newInfo.protocol = `${newInfo.protocol}:` as Protocol\n  }\n\n  const endPointInfo = findMatchedInfo(newInfo)\n  if (endPointInfo) {\n    // eslint-disable-next-line eqeqeq\n    if (newInfo.baseUrl != null) {\n      endPointInfo.baseUrl = newInfo.baseUrl\n    }\n    // eslint-disable-next-line eqeqeq\n    if (newInfo.protocol != null) {\n      endPointInfo.protocol = newInfo.protocol\n    }\n  } else {\n    END_POINT_INFO_ARR.push({ ...newInfo, protocol: newInfo.protocol ?? DEFAULT_PROTOCOL })\n  }\n\n  // 保持旧代码逻辑\n  if (newInfo.endPointKey === 'CLOUD_API') {\n    setUtilitiesProtocol((newInfo.protocol ?? DEFAULT_PROTOCOL) as 'http:' | 'https:')\n  }\n}\n\nexport function getEndPointInfo(env: string, endPointKey: EndPointKey, region?: string) {\n  return findMatchedInfo({ env, endPointKey, region })\n}\n\nexport interface ISetEndPointWithKey {\n  key: EndPointKey\n  url?: string\n  protocol?: 'http' | 'https'\n}\n\nexport function setGatewayEndPointWithEnv(env: string, protocol?: Protocol, init?: boolean) {\n  let baseUrl = `//${env}.api.tcloudbasegateway.com/v1`\n\n  if (init) {\n    baseUrl = `//${env}.api.intl.tcloudbasegateway.com/v1`\n  }\n\n  setEndPointInfo({ endPointKey: 'GATEWAY', env, baseUrl, protocol })\n}\nexport function setRegionLevelEndpoint(env: string, region: string, protocol?: Protocol) {\n  const baseUrl = `//${env}.${region || 'ap-shanghai'}.tcb-api.tencentcloudapi.com/web`\n  setEndPointInfo({ env, region, baseUrl, protocol, endPointKey: 'CLOUD_API' })\n}\n\nexport function getBaseEndPoint(env: string, endPointKey: EndPointKey = 'CLOUD_API') {\n  const info = getEndPointInfo(env, endPointKey || 'CLOUD_API')\n\n  const { protocol: PROTOCOL, baseUrl: BASE_URL } = info\n  const webEndpoint = `${PROTOCOL}${BASE_URL}`\n  // @todo 临时兼容小程序\n  return webEndpoint.match(/(http(s)?:)?\\/\\/([^/?#]*)/)[0]\n  // return `${new URL(webEndpoint).origin}`\n}\n\nexport enum LOGINTYPE {\n  NULL = 'NULL',\n  ANONYMOUS = 'ANONYMOUS',\n  WECHAT = 'WECHAT',\n  WECHAT_PUBLIC = 'WECHAT-PUBLIC',\n  WECHAT_OPEN = 'WECHAT-OPEN',\n  CUSTOM = 'CUSTOM',\n  EMAIL = 'EMAIL',\n  USERNAME = 'USERNAME',\n  PHONE = 'PHONE',\n}\n\nexport const OAUTH2_LOGINTYPE_PREFIX = 'OAUTH2'\n"]}

package/node_modules/@cloudbase/app/dist/esm/index.d.ts

@@ -0,0 +1,65 @@
+import { CloudbaseAdapter } from '@cloudbase/adapter-interface';
+import { ICloudbaseConfig, ICloudbaseUpgradedConfig, ICloudbase, ICloudbaseExtension, ICloudbasePlatformInfo, EndPointKey, ICloudbaseApis } from '@cloudbase/types';
+import { ICloudbaseAuth } from '@cloudbase/types/auth';
+import { ICloudbaseComponent, ICloudbaseHook } from '@cloudbase/types/component';
+import { ICloudbaseCache } from '@cloudbase/types/cache';
+import { ICloudbaseRequest } from '@cloudbase/types/request';
+import { type ISetEndPointWithKey } from './constants/common';
+import { LANGS } from './libs/lang';
+export { getBaseEndPoint } from './constants/common';
+export { LANGS } from './libs/lang';
+declare class Cloudbase implements ICloudbase {
+    authInstance: ICloudbaseAuth;
+    oauthInstance: any;
+    requestClient: any;
+    oauthClient: any;
+    version: string;
+    auth: ICloudbase['auth'] & ICloudbaseAuth;
+    apis: ICloudbaseApis;
+    private cloudbaseConfig;
+    constructor(config?: ICloudbaseConfig);
+    get config(): ICloudbaseConfig;
+    get platform(): ICloudbasePlatformInfo;
+    get cache(): ICloudbaseCache;
+    get localCache(): ICloudbaseCache;
+    get request(): ICloudbaseRequest;
+    init(config?: ICloudbaseConfig & {
+        lang?: LANGS;
+    }): Cloudbase;
+    updateConfig(config: ICloudbaseUpgradedConfig): void;
+    updateLang(lang: LANGS): void;
+    registerExtension(ext: ICloudbaseExtension): void;
+    invokeExtension(name: string, opts: any): any;
+    useAdapters(adapters: CloudbaseAdapter | CloudbaseAdapter[], options?: any): void;
+    registerHook(hook: ICloudbaseHook): void;
+    registerComponent(component: ICloudbaseComponent): void;
+    registerVersion(version: string): void;
+    registerSdkName(name: string): void;
+    isInitialized(config?: ICloudbaseConfig): boolean;
+    registerEndPoint(url: string, protocol?: 'http' | 'https'): void;
+    registerEndPointWithKey(props: ISetEndPointWithKey): void;
+    getEndPointWithKey(key: EndPointKey): {
+        BASE_URL: string;
+        PROTOCOL: "http" | "https" | "http:" | "https:";
+    };
+    parseCaptcha(url: any): {
+        error: string;
+        error_description: string;
+        state?: undefined;
+        token?: undefined;
+        captchaData?: undefined;
+    } | {
+        state: any;
+        token: any;
+        captchaData: any;
+        error?: undefined;
+        error_description?: undefined;
+    };
+    private useDefaultAdapter;
+    private formatTimeout;
+    private try2InitAuth;
+    private dealNodeAdapterConfig;
+}
+export type { Cloudbase };
+export declare const cloudbase: ICloudbase;
+export default cloudbase;

package/node_modules/@cloudbase/app/dist/esm/index.js

@@ -0,0 +1,335 @@
+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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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 };
+    }
+};
+import { adapters, constants, utils, helpers } from '@cloudbase/utilities';
+import { registerComponent, registerHook } from './libs/component';
+import { getWxDefaultAdapter, Platform } from './libs/adapter';
+import { initCache, getCacheByEnvId, getLocalCache } from './libs/cache';
+import { initRequest, getRequestByEnvId } from './libs/request';
+import { getSdkName, setSdkVersion, setRegionLevelEndpoint, setSdkName, setGatewayEndPointWithEnv, setEndPointInfo, getEndPointInfo, getSdkVersion, DEFAULT_PROTOCOL, } from './constants/common';
+import { i18nProxy } from './libs/lang';
+export { getBaseEndPoint } from './constants/common';
+export { LANGS } from './libs/lang';
+var useAdapters = adapters.useAdapters, useDefaultAdapter = adapters.useDefaultAdapter;
+var ERRORS = constants.ERRORS, COMMUNITY_SITE_URL = constants.COMMUNITY_SITE_URL;
+var printWarn = utils.printWarn;
+var catchErrorsDecorator = helpers.catchErrorsDecorator;
+var DEFAULT_INIT_CONFIG = {
+    timeout: 15000,
+    persistence: 'local',
+};
+var MAX_TIMEOUT = 1000 * 60 * 10;
+var MIN_TIMEOUT = 100;
+var extensionMap = {};
+var Cloudbase = (function () {
+    function Cloudbase(config) {
+        this.cloudbaseConfig = config ? config : this.cloudbaseConfig;
+        this.authInstance = null;
+        this.oauthInstance = null;
+        this.version = getSdkVersion();
+    }
+    Object.defineProperty(Cloudbase.prototype, "config", {
+        get: function () {
+            return this.cloudbaseConfig;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Cloudbase.prototype, "platform", {
+        get: function () {
+            return Platform;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Cloudbase.prototype, "cache", {
+        get: function () {
+            return getCacheByEnvId(this.cloudbaseConfig.env);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Cloudbase.prototype, "localCache", {
+        get: function () {
+            return getLocalCache(this.cloudbaseConfig.env);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Cloudbase.prototype, "request", {
+        get: function () {
+            return getRequestByEnvId(this.cloudbaseConfig.env);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Cloudbase.prototype.init = function (config) {
+        var _a, _b, _c;
+        if (config === void 0) { config = { env: '' }; }
+        config.endPointMode = config.endPointMode || 'GATEWAY';
+        if (!Platform.adapter) {
+            this.useDefaultAdapter();
+        }
+        config = this.dealNodeAdapterConfig(config);
+        if (!config.env) {
+            throw new Error(JSON.stringify({
+                code: ERRORS.INVALID_PARAMS,
+                msg: 'env must not be specified',
+            }));
+        }
+        this.isInitialized(config);
+        var reqConfig = {
+            timeout: config.timeout || 15000,
+            timeoutMsg: "[".concat(getSdkName(), "][REQUEST TIMEOUT] request had been abort since didn't finished within").concat(config.timeout / 1000, "s"),
+            auth: config.auth,
+        };
+        this.requestClient = new Platform.adapter.reqClass(reqConfig);
+        this.cloudbaseConfig = __assign(__assign(__assign({}, DEFAULT_INIT_CONFIG), config), { i18n: i18nProxy(Platform, config) });
+        delete this.cloudbaseConfig.lang;
+        this.cloudbaseConfig.timeout = this.formatTimeout(this.cloudbaseConfig.timeout);
+        var _d = this.cloudbaseConfig, env = _d.env, persistence = _d.persistence, debug = _d.debug, timeout = _d.timeout, oauthClient = _d.oauthClient, i18n = _d.i18n;
+        initCache({ env: env, persistence: persistence, debug: debug, platformInfo: this.platform });
+        setRegionLevelEndpoint(env, config.region || '');
+        setGatewayEndPointWithEnv(env, DEFAULT_PROTOCOL, config.intl);
+        var app = new Cloudbase(this.cloudbaseConfig);
+        initRequest({
+            env: env,
+            region: config.region || '',
+            timeout: timeout,
+            oauthClient: oauthClient,
+            _fromApp: app,
+            i18n: i18n,
+            endPointMode: config.endPointMode,
+            auth: config.auth,
+        });
+        app.requestClient = this.requestClient;
+        (_a = this === null || this === void 0 ? void 0 : this.fire) === null || _a === void 0 ? void 0 : _a.call(this, 'cloudbase_init', app);
+        this.try2InitAuth(app);
+        if ((_b = Platform.adapter) === null || _b === void 0 ? void 0 : _b.nodeTool) {
+            (_c = Platform.adapter) === null || _c === void 0 ? void 0 : _c.nodeTool(app, this.cloudbaseConfig);
+        }
+        return app;
+    };
+    Cloudbase.prototype.updateConfig = function (config) {
+        var persistence = config.persistence, debug = config.debug;
+        this.cloudbaseConfig.persistence = persistence;
+        this.cloudbaseConfig.debug = debug;
+        initCache({ env: this.cloudbaseConfig.env, persistence: persistence, debug: debug, platformInfo: this.platform });
+    };
+    Cloudbase.prototype.updateLang = function (lang) {
+        var _a;
+        if (!lang || lang === ((_a = this.cloudbaseConfig.i18n) === null || _a === void 0 ? void 0 : _a.lang))
+            return;
+        this.cloudbaseConfig.i18n.lang = lang;
+    };
+    Cloudbase.prototype.registerExtension = function (ext) {
+        extensionMap[ext.name] = ext;
+    };
+    Cloudbase.prototype.invokeExtension = function (name, opts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ext;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ext = extensionMap[name];
+                        if (!ext) {
+                            throw new Error(JSON.stringify({
+                                code: ERRORS.INVALID_PARAMS,
+                                msg: "extension:".concat(name, " must be registered before invoke"),
+                            }));
+                        }
+                        return [4, ext.invoke(opts, this)];
+                    case 1: return [2, _a.sent()];
+                }
+            });
+        });
+    };
+    Cloudbase.prototype.useAdapters = function (adapters, options) {
+        var _a = useAdapters(adapters, options) || {}, adapter = _a.adapter, runtime = _a.runtime;
+        adapter && (Platform.adapter = adapter);
+        runtime && (Platform.runtime = runtime);
+    };
+    Cloudbase.prototype.registerHook = function (hook) {
+        registerHook(Cloudbase, hook);
+    };
+    Cloudbase.prototype.registerComponent = function (component) {
+        registerComponent(Cloudbase, component);
+    };
+    Cloudbase.prototype.registerVersion = function (version) {
+        setSdkVersion(version);
+        this.version = version;
+    };
+    Cloudbase.prototype.registerSdkName = function (name) {
+        setSdkName(name);
+    };
+    Cloudbase.prototype.isInitialized = function (config) {
+        if (config === void 0) { config = this.cloudbaseConfig; }
+        var PLACEHOLDER_PATTERNS = [
+            'your-env-id',
+            'your-envid',
+            'your_env_id',
+            'xxx-yyy',
+            'xxxx-yyy',
+            'envId',
+            'env-id',
+            'your-environment-id',
+            'REPLACE_ME',
+        ];
+        if (PLACEHOLDER_PATTERNS.some(function (p) { return config.env.toLowerCase() === p.toLowerCase(); })) {
+            printWarn(ERRORS.INVALID_PARAMS, "[CloudBase] \u68C0\u6D4B\u5230\u73AF\u5883 ID \"".concat(config.env, "\" \u53EF\u80FD\u662F\u5360\u4F4D\u7B26\uFF0C\u8BF7\u66FF\u6362\u4E3A\u771F\u5B9E\u7684\u73AF\u5883 ID\u3002\n")
+                + '  获取方式：登录腾讯云开发平台 → 环境管理 → 环境设置 → 环境 ID\n'
+                + '  建议通过环境变量配置：process.env.CLOUDBASE_ENV 或 import.meta.env.VITE_CLOUDBASE_ENV');
+        }
+        return !!(config === null || config === void 0 ? void 0 : config.env);
+    };
+    Cloudbase.prototype.registerEndPoint = function (url, protocol) {
+        setEndPointInfo({ baseUrl: url, protocol: protocol, env: this.config.env, endPointKey: 'CLOUD_API' });
+    };
+    Cloudbase.prototype.registerEndPointWithKey = function (props) {
+        setEndPointInfo({
+            env: this.config.env,
+            endPointKey: props.key,
+            baseUrl: props.url,
+            protocol: props.protocol,
+        });
+    };
+    Cloudbase.prototype.getEndPointWithKey = function (key) {
+        var info = getEndPointInfo(this.config.env, key);
+        return {
+            BASE_URL: info.baseUrl,
+            PROTOCOL: info.protocol,
+        };
+    };
+    Cloudbase.prototype.parseCaptcha = function (url) {
+        return utils.parseCaptcha(url);
+    };
+    Cloudbase.prototype.useDefaultAdapter = function () {
+        var _a = useDefaultAdapter.bind(this)(), adapter = _a.adapter, runtime = _a.runtime;
+        Platform.adapter = adapter;
+        Platform.runtime = runtime;
+    };
+    Cloudbase.prototype.formatTimeout = function (timeout) {
+        switch (true) {
+            case timeout > MAX_TIMEOUT:
+                printWarn(ERRORS.INVALID_PARAMS, 'timeout is greater than maximum value[10min]');
+                return MAX_TIMEOUT;
+            case timeout < MIN_TIMEOUT:
+                printWarn(ERRORS.INVALID_PARAMS, 'timeout is less than maximum value[100ms]');
+                return MIN_TIMEOUT;
+            default:
+                return timeout;
+        }
+    };
+    Cloudbase.prototype.try2InitAuth = function (app) {
+        try {
+            app.auth();
+        }
+        catch (error) {
+            console.log('try2InitAuth error:', error);
+        }
+    };
+    Cloudbase.prototype.dealNodeAdapterConfig = function (config) {
+        var _a, _b;
+        if (typeof process !== 'undefined'
+            && typeof process.env !== 'undefined'
+            && !process.env.IS_BROWSER_BUILD
+            && ((_a = Platform.adapter) === null || _a === void 0 ? void 0 : _a.getSecretInfo)) {
+            var secretInfo = (_b = Platform.adapter) === null || _b === void 0 ? void 0 : _b.getSecretInfo(config);
+            config.auth = __assign(__assign({}, config.auth), { secretId: secretInfo.secretId, secretKey: secretInfo.secretKey, sessionToken: secretInfo.sessionToken, secretType: secretInfo.secretType });
+            if (!config.env) {
+                config.env = secretInfo.env;
+            }
+            if (!config.accessKey && secretInfo.accessKey) {
+                config.accessKey = secretInfo.accessKey;
+            }
+        }
+        return config;
+    };
+    __decorate([
+        catchErrorsDecorator({
+            mode: 'sync',
+            title: 'Cloudbase 初始化失败',
+            messages: [
+                '请确认以下各项：',
+                '  1 - 调用 cloudbase.init() 的语法或参数是否正确',
+                '  2 - 如果是非浏览器环境，是否配置了安全应用来源（https://docs.cloudbase.net/api-reference/webv3/adapter#%E7%AC%AC-2-%E6%AD%A5%E9%85%8D%E7%BD%AE%E5%AE%89%E5%85%A8%E5%BA%94%E7%94%A8%E6%9D%A5%E6%BA%90）',
+                "\u5982\u679C\u95EE\u9898\u4F9D\u7136\u5B58\u5728\uFF0C\u5EFA\u8BAE\u5230\u5B98\u65B9\u95EE\u7B54\u793E\u533A\u63D0\u95EE\u6216\u5BFB\u627E\u5E2E\u52A9\uFF1A".concat(COMMUNITY_SITE_URL),
+            ],
+        }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Cloudbase)
+    ], Cloudbase.prototype, "init", null);
+    __decorate([
+        catchErrorsDecorator({
+            title: '调用扩展能力失败',
+            messages: [
+                '请确认以下各项：',
+                '  1 - 调用 invokeExtension() 的语法或参数是否正确',
+                '  2 - 被调用的扩展能力是否已经安装并通过 registerExtension() 注册',
+                "\u5982\u679C\u95EE\u9898\u4F9D\u7136\u5B58\u5728\uFF0C\u5EFA\u8BAE\u5230\u5B98\u65B9\u95EE\u7B54\u793E\u533A\u63D0\u95EE\u6216\u5BFB\u627E\u5E2E\u52A9\uFF1A".concat(COMMUNITY_SITE_URL),
+            ],
+        }),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [String, Object]),
+        __metadata("design:returntype", Promise)
+    ], Cloudbase.prototype, "invokeExtension", null);
+    return Cloudbase;
+}());
+export var cloudbase = new Cloudbase();
+cloudbase.useAdapters(getWxDefaultAdapter());
+export default cloudbase;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { adapters, constants, utils, helpers } from '@cloudbase/utilities'\nimport { SDKAdapterInterface, CloudbaseAdapter, IRequestConfig } from '@cloudbase/adapter-interface'\nimport {\n  ICloudbaseConfig,\n  ICloudbaseUpgradedConfig,\n  ICloudbase,\n  ICloudbaseExtension,\n  KV,\n  ICloudbasePlatformInfo,\n  EndPointKey,\n  ICloudbaseApis,\n} from '@cloudbase/types'\nimport { ICloudbaseAuth } from '@cloudbase/types/auth'\nimport { registerComponent, registerHook } from './libs/component'\nimport { getWxDefaultAdapter, Platform } from './libs/adapter'\nimport { ICloudbaseComponent, ICloudbaseHook } from '@cloudbase/types/component'\nimport { ICloudbaseCache } from '@cloudbase/types/cache'\nimport { initCache, getCacheByEnvId, getLocalCache } from './libs/cache'\nimport { ICloudbaseRequest } from '@cloudbase/types/request'\nimport { initRequest, getRequestByEnvId } from './libs/request'\nimport {\n  getSdkName,\n  setSdkVersion,\n  setRegionLevelEndpoint,\n  setSdkName,\n  setGatewayEndPointWithEnv,\n  type ISetEndPointWithKey,\n  setEndPointInfo,\n  getEndPointInfo,\n  getSdkVersion,\n  DEFAULT_PROTOCOL,\n} from './constants/common'\nimport { i18nProxy, LANGS } from './libs/lang'\nexport { getBaseEndPoint } from './constants/common'\nexport { LANGS } from './libs/lang'\nconst { useAdapters, useDefaultAdapter } = adapters\nconst { ERRORS, COMMUNITY_SITE_URL } = constants\nconst { printWarn } = utils\nconst { catchErrorsDecorator } = helpers\n\n/**\n * @constant 默认配置\n */\nconst DEFAULT_INIT_CONFIG: Partial<ICloudbaseConfig> = {\n  timeout: 15000,\n  persistence: 'local', // 持久化存储类型\n}\n\n// timeout上限10分钟\nconst MAX_TIMEOUT = 1000 * 60 * 10\n// timeout下限100ms\nconst MIN_TIMEOUT = 100\n\nconst extensionMap: KV<ICloudbaseExtension> = {}\n\nclass Cloudbase implements ICloudbase {\n  public authInstance: ICloudbaseAuth\n  public oauthInstance: any\n  public requestClient: any\n  public oauthClient: any\n  public version: string\n  public auth: ICloudbase['auth'] & ICloudbaseAuth\n  public apis: ICloudbaseApis\n  private cloudbaseConfig: ICloudbaseConfig\n\n  constructor(config?: ICloudbaseConfig) {\n    this.cloudbaseConfig = config ? config : this.cloudbaseConfig\n    this.authInstance = null\n    this.oauthInstance = null\n    this.version = getSdkVersion()\n  }\n\n  get config() {\n    return this.cloudbaseConfig\n  }\n\n  get platform(): ICloudbasePlatformInfo {\n    return Platform\n  }\n\n  get cache(): ICloudbaseCache {\n    return getCacheByEnvId(this.cloudbaseConfig.env)\n  }\n\n  get localCache(): ICloudbaseCache {\n    return getLocalCache(this.cloudbaseConfig.env)\n  }\n\n  get request(): ICloudbaseRequest {\n    return getRequestByEnvId(this.cloudbaseConfig.env)\n  }\n\n  @catchErrorsDecorator({\n    mode: 'sync',\n    title: 'Cloudbase 初始化失败',\n    messages: [\n      '请确认以下各项：',\n      '  1 - 调用 cloudbase.init() 的语法或参数是否正确',\n      '  2 - 如果是非浏览器环境，是否配置了安全应用来源（https://docs.cloudbase.net/api-reference/webv3/adapter#%E7%AC%AC-2-%E6%AD%A5%E9%85%8D%E7%BD%AE%E5%AE%89%E5%85%A8%E5%BA%94%E7%94%A8%E6%9D%A5%E6%BA%90）',\n      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,\n    ],\n  })\n  public init(config: ICloudbaseConfig & { lang?: LANGS } = { env: '' }): Cloudbase {\n    config.endPointMode = config.endPointMode || 'GATEWAY'\n\n    // 初始化时若未兼容平台，则使用默认adapter\n    if (!Platform.adapter) {\n      this.useDefaultAdapter()\n    }\n\n    // 在判断config.env之前，先处理node环境的配置\n    config = this.dealNodeAdapterConfig(config)\n\n    if (!config.env) {\n      throw new Error(JSON.stringify({\n        code: ERRORS.INVALID_PARAMS,\n        msg: 'env must not be specified',\n      }),)\n    }\n\n    this.isInitialized(config)\n\n    const reqConfig: IRequestConfig & { auth: ICloudbaseConfig['auth'] } = {\n      timeout: config.timeout || 15000,\n      timeoutMsg: `[${getSdkName()}][REQUEST TIMEOUT] request had been abort since didn't finished within${\n        config.timeout / 1000\n      }s`,\n      auth: config.auth,\n    }\n\n    this.requestClient = new Platform.adapter.reqClass(reqConfig)\n\n    this.cloudbaseConfig = {\n      ...DEFAULT_INIT_CONFIG,\n      ...config,\n      i18n: i18nProxy(Platform, config),\n    }\n\n    delete (this.cloudbaseConfig as any).lang\n    // 修正timeout取值\n    this.cloudbaseConfig.timeout = this.formatTimeout(this.cloudbaseConfig.timeout)\n    // 初始化cache和request\n    const { env, persistence, debug, timeout, oauthClient, i18n } = this.cloudbaseConfig\n    initCache({ env, persistence, debug, platformInfo: this.platform })\n\n    setRegionLevelEndpoint(env, config.region || '')\n    setGatewayEndPointWithEnv(env, DEFAULT_PROTOCOL, config.intl)\n\n    const app = new Cloudbase(this.cloudbaseConfig)\n    initRequest({\n      env,\n      region: config.region || '',\n      timeout,\n      oauthClient,\n      _fromApp: app,\n      i18n,\n      endPointMode: config.endPointMode,\n      auth: config.auth,\n    })\n    app.requestClient = this.requestClient\n    ;(this as any)?.fire?.('cloudbase_init', app)\n\n    this.try2InitAuth(app)\n\n    // node环境可以从adapter获取nodeTool的方法\n    if (Platform.adapter?.nodeTool) {\n      Platform.adapter?.nodeTool(app, this.cloudbaseConfig)\n    }\n\n    return app\n  }\n\n  public updateConfig(config: ICloudbaseUpgradedConfig) {\n    const { persistence, debug } = config\n    this.cloudbaseConfig.persistence = persistence\n    this.cloudbaseConfig.debug = debug\n    // persistence改动影响cache\n    initCache({ env: this.cloudbaseConfig.env, persistence, debug, platformInfo: this.platform })\n  }\n\n  public updateLang(lang: LANGS) {\n    if (!lang || lang === this.cloudbaseConfig.i18n?.lang) return\n\n    this.cloudbaseConfig.i18n.lang = lang\n  }\n\n  public registerExtension(ext: ICloudbaseExtension) {\n    extensionMap[ext.name] = ext\n  }\n  @catchErrorsDecorator({\n    title: '调用扩展能力失败',\n    messages: [\n      '请确认以下各项：',\n      '  1 - 调用 invokeExtension() 的语法或参数是否正确',\n      '  2 - 被调用的扩展能力是否已经安装并通过 registerExtension() 注册',\n      `如果问题依然存在，建议到官方问答社区提问或寻找帮助：${COMMUNITY_SITE_URL}`,\n    ],\n  })\n  public async invokeExtension(name: string, opts: any) {\n    const ext = extensionMap[name]\n    if (!ext) {\n      throw new Error(JSON.stringify({\n        code: ERRORS.INVALID_PARAMS,\n        msg: `extension:${name} must be registered before invoke`,\n      }),)\n    }\n\n    return await ext.invoke(opts, this)\n  }\n\n  public useAdapters(adapters: CloudbaseAdapter | CloudbaseAdapter[], options?: any) {\n    const { adapter, runtime } = useAdapters(adapters, options) || {}\n    adapter && (Platform.adapter = adapter as SDKAdapterInterface)\n    runtime && (Platform.runtime = runtime as string)\n  }\n\n  public registerHook(hook: ICloudbaseHook) {\n    registerHook(Cloudbase, hook)\n  }\n\n  public registerComponent(component: ICloudbaseComponent) {\n    registerComponent(Cloudbase, component)\n  }\n\n  public registerVersion(version: string) {\n    setSdkVersion(version)\n    this.version = version\n  }\n\n  public registerSdkName(name: string) {\n    setSdkName(name)\n  }\n\n  /**\n   * 检查当前 Cloudbase 实例是否已完成初始化\n   *\n   * @example\n   * ```javascript\n   * import cloudbase from '@cloudbase/js-sdk'\n   *\n   * // 初始化前\n   * console.log(cloudbase.isInitialized()) // false\n   *\n   * const app = cloudbase.init({ env: 'your-env-id' })\n   *\n   * // 初始化后\n   * console.log(app.isInitialized()) // true\n   * ```\n   *\n   * @returns {boolean} 是否已初始化\n   */\n  public isInitialized(config = this.cloudbaseConfig): boolean {\n    // 检测常见占位符 env 值，在开发阶段给出友好提示\n    const PLACEHOLDER_PATTERNS = [\n      'your-env-id',\n      'your-envid',\n      'your_env_id',\n      'xxx-yyy',\n      'xxxx-yyy',\n      'envId',\n      'env-id',\n      'your-environment-id',\n      'REPLACE_ME',\n    ]\n    if (PLACEHOLDER_PATTERNS.some(p => config.env.toLowerCase() === p.toLowerCase())) {\n      printWarn(\n        ERRORS.INVALID_PARAMS,\n        `[CloudBase] 检测到环境 ID \"${config.env}\" 可能是占位符，请替换为真实的环境 ID。\\n`\n          + '  获取方式：登录腾讯云开发平台 → 环境管理 → 环境设置 → 环境 ID\\n'\n          + '  建议通过环境变量配置：process.env.CLOUDBASE_ENV 或 import.meta.env.VITE_CLOUDBASE_ENV',\n      )\n    }\n\n    return !!config?.env\n  }\n\n  /** 设置 tcb api 的 endpoint */\n  public registerEndPoint(url: string, protocol?: 'http' | 'https') {\n    setEndPointInfo({ baseUrl: url, protocol, env: this.config.env, endPointKey: 'CLOUD_API' })\n  }\n\n  /** 设置网关/tcb api的 endPoint，通过 key 指定 */\n  public registerEndPointWithKey(props: ISetEndPointWithKey) {\n    setEndPointInfo({\n      env: this.config.env,\n      endPointKey: props.key,\n      baseUrl: props.url,\n      protocol: props.protocol,\n    })\n  }\n\n  /** 拿网关/tcb api的 endPoint，通过 key 指定 */\n  public getEndPointWithKey(key: EndPointKey) {\n    const info = getEndPointInfo(this.config.env, key)\n    return {\n      BASE_URL: info.baseUrl,\n      PROTOCOL: info.protocol,\n    }\n  }\n\n  // 解析URL参数\n  public parseCaptcha(url) {\n    return utils.parseCaptcha(url)\n  }\n\n  private useDefaultAdapter() {\n    const { adapter, runtime } = useDefaultAdapter.bind(this)()\n    Platform.adapter = adapter as SDKAdapterInterface\n    Platform.runtime = runtime as string\n  }\n\n  private formatTimeout(timeout: number) {\n    switch (true) {\n      case timeout > MAX_TIMEOUT:\n        printWarn(ERRORS.INVALID_PARAMS, 'timeout is greater than maximum value[10min]')\n        return MAX_TIMEOUT\n      case timeout < MIN_TIMEOUT:\n        printWarn(ERRORS.INVALID_PARAMS, 'timeout is less than maximum value[100ms]')\n        return MIN_TIMEOUT\n      default:\n        return timeout\n    }\n  }\n\n  private try2InitAuth(app) {\n    try {\n      app.auth()\n    } catch (error) {\n      console.log('try2InitAuth error:', error)\n    }\n  }\n\n  /**\n   * 处理 Node 环境下 adapter 的配置信息\n   * 在 Node 环境中，通过 adapter 自动获取密钥、环境ID、accessKey 等配置，\n   * 减少用户手动传入配置的负担\n   * @param config - 云开发初始化配置对象\n   * @returns 补充了 Node adapter 信息后的配置对象\n   */\n  private dealNodeAdapterConfig(config: ICloudbaseConfig) {\n    // node环境可以从adapter获取默认的secretId和secretKey\n    if (\n      typeof process !== 'undefined'\n      && typeof process.env !== 'undefined'\n      && !process.env.IS_BROWSER_BUILD\n      && Platform.adapter?.getSecretInfo\n    ) {\n      const secretInfo = Platform.adapter?.getSecretInfo(config)\n      // 将 adapter 提供的密钥信息写入 config.auth\n      config.auth = {\n        ...config.auth,\n        secretId: secretInfo.secretId,\n        secretKey: secretInfo.secretKey,\n        sessionToken: secretInfo.sessionToken,\n        secretType: secretInfo.secretType as any,\n      }\n\n      // node 环境可能可以从上下文获取env，用户未显式指定时自动填充\n      if (!config.env) {\n        config.env = secretInfo.env\n      }\n\n      // node adapter环境能读取到 process.env.CLOUDBASE_APIKEY 时，在没有传入accessKey时，使用 node adapter 提供的 accessKey（process.env.CLOUDBASE_APIKEY）\n      if (!config.accessKey && secretInfo.accessKey) {\n        config.accessKey = secretInfo.accessKey\n      }\n    }\n\n    return config\n  }\n}\n\n// 类型导出\nexport type { Cloudbase }\n\n// 值导出\nexport const cloudbase: ICloudbase = new Cloudbase()\n\ncloudbase.useAdapters(getWxDefaultAdapter())\n\n// 默认导出实例\nexport default cloudbase\n"]}

package/node_modules/@cloudbase/app/dist/esm/index.node.d.ts

@@ -0,0 +1,6 @@
+import cloudbase from './index';
+export { getBaseEndPoint } from './constants/common';
+export { LANGS } from './libs/lang';
+export type { Cloudbase } from './index';
+export { cloudbase };
+export default cloudbase;

package/node_modules/@cloudbase/app/dist/esm/index.node.js

@@ -0,0 +1,12 @@
+import cloudbase from './index';
+export { getBaseEndPoint } from './constants/common';
+export { LANGS } from './libs/lang';
+export { cloudbase };
+try {
+    var nodeAdapter = require('./libs/adapter-node').default;
+    cloudbase.useAdapters(nodeAdapter);
+}
+catch (error) {
+}
+export default cloudbase;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXgubm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbmRleC5ub2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sU0FBUyxNQUFNLFNBQVMsQ0FBQTtBQUUvQixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sb0JBQW9CLENBQUE7QUFDcEQsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLGFBQWEsQ0FBQTtBQUVuQyxPQUFPLEVBQUUsU0FBUyxFQUFFLENBQUE7QUFHcEIsSUFBSTtJQUVGLElBQU0sV0FBVyxHQUFHLE9BQU8sQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDLE9BQU8sQ0FBQTtJQUMxRCxTQUFTLENBQUMsV0FBVyxDQUFDLFdBQVcsQ0FBQyxDQUFBO0NBQ25DO0FBQUMsT0FBTyxLQUFLLEVBQUU7Q0FFZjtBQUdELGVBQWUsU0FBUyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBOb2RlLmpzIOWFpeWPo1xuICog5byV55SoIGJhc2Ug5qih5Z2X55qE5YWo6YOo5a+85Ye677yM5bm26aKd5aSW5Yqg6L29IE5vZGUgYWRhcHRlclxuICovXG5pbXBvcnQgY2xvdWRiYXNlIGZyb20gJy4vaW5kZXgnXG5cbmV4cG9ydCB7IGdldEJhc2VFbmRQb2ludCB9IGZyb20gJy4vY29uc3RhbnRzL2NvbW1vbidcbmV4cG9ydCB7IExBTkdTIH0gZnJvbSAnLi9saWJzL2xhbmcnXG5leHBvcnQgdHlwZSB7IENsb3VkYmFzZSB9IGZyb20gJy4vaW5kZXgnXG5leHBvcnQgeyBjbG91ZGJhc2UgfVxuXG4vLyBOb2RlIOeOr+Wig+S4i+WKoOi9vSBOb2RlIGFkYXB0ZXJcbnRyeSB7XG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tdmFyLXJlcXVpcmVzLCBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tcmVxdWlyZS1pbXBvcnRzXG4gIGNvbnN0IG5vZGVBZGFwdGVyID0gcmVxdWlyZSgnLi9saWJzL2FkYXB0ZXItbm9kZScpLmRlZmF1bHRcbiAgY2xvdWRiYXNlLnVzZUFkYXB0ZXJzKG5vZGVBZGFwdGVyKVxufSBjYXRjaCAoZXJyb3IpIHtcbiAgLy8gdGhyb3cgZXJyb3Jcbn1cblxuLy8g6buY6K6k5a+85Ye65a6e5L6LXG5leHBvcnQgZGVmYXVsdCBjbG91ZGJhc2VcbiJdfQ==

package/node_modules/@cloudbase/app/dist/esm/libs/adapter-node/constants.d.ts

@@ -0,0 +1,33 @@
+export declare const ERROR: {
+    INVALID_PARAM: {
+        code: string;
+        message: string;
+    };
+    SYS_ERR: {
+        code: string;
+        message: string;
+    };
+    STORAGE_REQUEST_FAIL: {
+        code: string;
+        message: string;
+    };
+    STORAGE_FILE_NONEXIST: {
+        code: string;
+        message: string;
+    };
+    TCB_CLS_UNOPEN: {
+        code: string;
+        message: string;
+    };
+    INVALID_CONTEXT: {
+        code: string;
+        message: string;
+    };
+};
+export declare const ADMIN_PATH = "/admin";
+export declare const CLIENT_AUTH_PATH = "/auth/v1/token/clientCredential";
+export declare const checkCustomUserIdRegex: RegExp;
+export declare enum SECRET_TYPE {
+    'SECRET' = "SECRET",
+    'SESSION_SECRET' = "SESSION_SECRET"
+}