@coze/cli 0.0.2

package/dist/commands/base.d.ts

@@ -0,0 +1,15 @@
+import { type Argument, type Option, type Command } from 'commander';
+export interface CommandSpec {
+    name: string;
+    description: string;
+    action?: (...args: any[]) => Promise<void> | void;
+    subCommands?: CommandSpec[];
+    options?: Option[];
+    arguments?: Argument[];
+    auth?: boolean;
+}
+export declare function addCommand({ program, spec, runAuth, }: {
+    program: Command;
+    spec: CommandSpec;
+    runAuth?: () => Promise<void>;
+}): void;

package/dist/commands/base.js

@@ -0,0 +1,28 @@
+export function addCommand({ program, spec, runAuth, }) {
+    var _a, _b, _c;
+    const command = program.command(spec.name);
+    command.description(spec.description);
+    ((_a = spec.arguments) !== null && _a !== void 0 ? _a : []).forEach((argument) => {
+        command.addArgument(argument);
+    });
+    ((_b = spec.options) !== null && _b !== void 0 ? _b : []).forEach((option) => {
+        command.addOption(option);
+    });
+    if (spec.action) {
+        command.action(async (...args) => {
+            var _a;
+            if (spec.auth && runAuth) {
+                await runAuth();
+            }
+            await ((_a = spec.action) === null || _a === void 0 ? void 0 : _a.call(spec, ...args));
+        });
+    }
+    ((_c = spec.subCommands) !== null && _c !== void 0 ? _c : []).forEach(subCommand => {
+        addCommand({
+            program: command,
+            spec: subCommand,
+            runAuth,
+        });
+    });
+}
+//# sourceMappingURL=base.js.map

package/dist/commands/login.d.ts

@@ -0,0 +1,6 @@
+import { type Region } from '../helpers/constants';
+import { type CommandSpec } from './base';
+export declare function loginAction({ region }: {
+    region?: Region;
+}): Promise<void>;
+export declare const loginSpec: CommandSpec;

package/dist/commands/login.js

@@ -0,0 +1,18 @@
+import { Option } from 'commander';
+import { OauthClient } from '../oauth';
+import { NpmConfig } from '../npm';
+import { REGION_VALUES } from '../helpers/constants';
+export async function loginAction({ region }) {
+    const npmConfig = new NpmConfig({ region });
+    const authClient = new OauthClient(region);
+    await authClient.activate(npmConfig);
+}
+export const loginSpec = {
+    name: 'login',
+    description: 'log in to the hub',
+    action: loginAction,
+    options: [
+        new Option('-r, --region <name>', 'the region of hub').choices(REGION_VALUES),
+    ],
+};
+//# sourceMappingURL=login.js.map

package/dist/commands/logout.d.ts

@@ -0,0 +1,8 @@
+import { type Region } from '../helpers/constants';
+import { type CommandSpec } from './base';
+export declare function logoutAction({ region, scope, source, }: {
+    region?: Region;
+    scope?: string;
+    source?: string;
+}): Promise<void>;
+export declare const logoutSpec: CommandSpec;

package/dist/commands/logout.js

@@ -0,0 +1,20 @@
+import { Option } from 'commander';
+import { OauthClient } from '../oauth';
+import { NpmConfig } from '../npm';
+import { REGION_VALUES } from '../helpers/constants';
+export async function logoutAction({ region, scope, source, }) {
+    const npmConfig = new NpmConfig({ region, scope, source });
+    const authClient = new OauthClient(region);
+    await authClient.deactivate(npmConfig);
+}
+export const logoutSpec = {
+    name: 'logout',
+    description: 'log out of the hub',
+    action: logoutAction,
+    options: [
+        new Option('-r, --region <name>', 'the region of hub').choices(REGION_VALUES),
+        new Option('-s, --scope <name>', 'the scope of package'),
+        new Option('-b, --source <name>', 'the business source'),
+    ],
+};
+//# sourceMappingURL=logout.js.map

package/dist/helpers/constants.d.ts

@@ -0,0 +1,10 @@
+export declare enum Region {
+    CN = "cn"
+}
+declare let REGISTRY_HOST: Record<string, string>;
+declare let CLIENT_ID_MAP: Record<string, string>;
+declare let ISSUER_MAP: Record<string, string>;
+declare let REGION_VALUES: string[];
+declare let isLocalDev: (region: string) => boolean;
+export declare const DEFAULT_REGION = Region.CN;
+export { REGION_VALUES, isLocalDev, REGISTRY_HOST, CLIENT_ID_MAP, ISSUER_MAP };

package/dist/helpers/constants.js

@@ -0,0 +1,44 @@
+export var Region;
+(function (Region) {
+    Region["CN"] = "cn";
+    // I18N = 'i18n',
+})(Region || (Region = {}));
+let REGISTRY_HOST = {
+    [Region.CN]: 'npm-hub.coze.cn',
+    // [Region.I18N]: 'npm-hub.coze.com',
+};
+let CLIENT_ID_MAP = {
+    [Region.CN]: '13474932957575400683007237571476.app.coze',
+};
+let ISSUER_MAP = {
+    [Region.CN]: 'https://api.coze.cn',
+};
+let REGION_VALUES = Object.values(Region);
+let isLocalDev = () => false;
+if (import.meta.env.PUBLIC_INHOUSE) {
+    let DevRegion;
+    (function (DevRegion) {
+        DevRegion["LOCAL"] = "local";
+        DevRegion["CN_BOE"] = "boe";
+    })(DevRegion || (DevRegion = {}));
+    REGISTRY_HOST = {
+        ...REGISTRY_HOST,
+        [DevRegion.CN_BOE]: 'npm-hub-boe.bytedance.net',
+        [DevRegion.LOCAL]: 'localhost:3000',
+    };
+    CLIENT_ID_MAP = {
+        ...CLIENT_ID_MAP,
+        [DevRegion.CN_BOE]: '70653688608994412341629476687797.app.coze',
+        [DevRegion.LOCAL]: '70653688608994412341629476687797.app.coze',
+    };
+    ISSUER_MAP = {
+        ...ISSUER_MAP,
+        [DevRegion.CN_BOE]: 'https://api-bot-boe.bytedance.net',
+        [DevRegion.LOCAL]: 'https://api-bot-boe.bytedance.net',
+    };
+    REGION_VALUES = Object.values({ ...DevRegion, ...Region });
+    isLocalDev = (region) => region === DevRegion.LOCAL;
+}
+export const DEFAULT_REGION = Region.CN;
+export { REGION_VALUES, isLocalDev, REGISTRY_HOST, CLIENT_ID_MAP, ISSUER_MAP };
+//# sourceMappingURL=constants.js.map

package/dist/helpers/logger.d.ts

@@ -0,0 +1,7 @@
+export declare const logger: {
+    info(...messages: unknown[]): void;
+    success(...messages: unknown[]): void;
+    warning(...messages: unknown[]): void;
+    error(...messages: unknown[]): void;
+    debug(...messages: unknown[]): void;
+};

package/dist/helpers/logger.js

@@ -0,0 +1,21 @@
+import colors from 'picocolors';
+export const logger = {
+    info(...messages) {
+        console.log(colors.blue('[INFO]'), ...messages);
+    },
+    success(...messages) {
+        console.log(colors.green('[SUCCESS]'), ...messages);
+    },
+    warning(...messages) {
+        console.log(colors.yellow('[WARNING]'), ...messages);
+    },
+    error(...messages) {
+        console.error(colors.red('[ERROR]'), ...messages);
+    },
+    debug(...messages) {
+        if (process.env.DEBUG) {
+            console.log(colors.magenta('[DEBUG]'), ...messages);
+        }
+    },
+};
+//# sourceMappingURL=logger.js.map

package/dist/helpers/package.d.ts

@@ -0,0 +1,8 @@
+export declare function resolvePackageJson(projectDir: string): Record<string, any>;
+export declare function resolvePackageDir(dir?: string): string;
+/**
+ * @coze/a-b -> __coze__a_b
+ * @coze-ui/a-b -> __coze_ui__a_b
+ * a-b -> a_b
+ */
+export declare function pkgName2RemoteName(pkgName: string): string;

package/dist/helpers/package.js

@@ -0,0 +1,33 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- ignore */
+/* eslint-disable security/detect-non-literal-fs-filename -- ignore */
+import path from 'node:path';
+import fs from 'node:fs';
+export function resolvePackageJson(projectDir) {
+    const pkgJsonFilePath = path.join(projectDir, 'package.json');
+    if (!fs.existsSync(pkgJsonFilePath)) {
+        throw new Error(`package.json not found in ${projectDir}`);
+    }
+    const content = fs.readFileSync(pkgJsonFilePath, 'utf-8');
+    return JSON.parse(content);
+}
+export function resolvePackageDir(dir = '') {
+    if (path.isAbsolute(dir)) {
+        return dir;
+    }
+    else {
+        return path.join(process.cwd(), dir);
+    }
+}
+/**
+ * @coze/a-b -> __coze__a_b
+ * @coze-ui/a-b -> __coze_ui__a_b
+ * a-b -> a_b
+ */
+export function pkgName2RemoteName(pkgName) {
+    const hasScope = pkgName.startsWith('@');
+    const parts = pkgName.split('/');
+    return `${hasScope ? `__${parts[0].slice(1)}__` : parts[0]}${parts
+        .slice(1)
+        .join('_')}`.replace(/-/g, '_');
+}
+//# sourceMappingURL=package.js.map

package/dist/helpers/request.d.ts

@@ -0,0 +1,3 @@
+import { type AxiosRequestConfig } from 'axios';
+export type RequestConfig = (url: string, options: AxiosRequestConfig) => Promise<AxiosRequestConfig>;
+export declare function loadRequestConfig(): Promise<RequestConfig | undefined>;

package/dist/helpers/request.js

@@ -0,0 +1,24 @@
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+import { logger } from './logger';
+export async function loadRequestConfig() {
+    const configPath = path.join(os.homedir(), '.coze-hub', 'request.js');
+    if (!fs.existsSync(configPath)) {
+        return undefined;
+    }
+    try {
+        const fileContent = fs.readFileSync(configPath, 'utf8');
+        const moduleWrapper = new Function('module', 'exports', fileContent);
+        const module = { exports: {} };
+        await moduleWrapper(module, module.exports);
+        const config = module.exports;
+        logger.info('loadRequestConfig', config);
+        return config;
+    }
+    catch (error) {
+        logger.warning('Failed to load request config:', error);
+        return undefined;
+    }
+}
+//# sourceMappingURL=request.js.map

package/dist/helpers/types.d.ts

@@ -0,0 +1,16 @@
+import { type TokenSetParameters } from 'openid-client';
+export interface BaseConfigData {
+    authToken: string;
+    refreshToken: string;
+    registryUrl: string;
+    scope?: string;
+}
+export interface INpmConfig<T extends BaseConfigData = BaseConfigData> {
+    loadConfig: () => Promise<T>;
+    storeToken: (token: TokenSetParameters) => Promise<void>;
+    clearToken: () => Promise<void>;
+}
+export interface IAuthClient {
+    activate: (npmConfig: INpmConfig) => Promise<void>;
+    deactivate: (npmConfig: INpmConfig) => Promise<void>;
+}

package/dist/helpers/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { addCommand, type CommandSpec } from './commands/base';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { addCommand } from './commands/base';
+//# sourceMappingURL=index.js.map

package/dist/index.mjs

@@ -0,0 +1,263 @@
+import * as __WEBPACK_EXTERNAL_MODULE_node_path__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_node_module__ from "node:module";
+import * as __WEBPACK_EXTERNAL_MODULE__rsbuild_core__ from "@rsbuild/core";
+import * as __WEBPACK_EXTERNAL_MODULE_lodash__ from "lodash";
+import * as __WEBPACK_EXTERNAL_MODULE__rsbuild_plugin_react__ from "@rsbuild/plugin-react";
+import * as __WEBPACK_EXTERNAL_MODULE__rsbuild_plugin_less__ from "@rsbuild/plugin-less";
+import * as __WEBPACK_EXTERNAL_MODULE_picocolors__ from "picocolors";
+import "prettier";
+import * as __WEBPACK_EXTERNAL_MODULE__rslib_core__ from "@rslib/core";
+import * as __WEBPACK_EXTERNAL_MODULE_commander__ from "commander";
+/* eslint-disable @typescript-eslint/no-explicit-any -- ignore */ function addCommand({ program, spec, runAuth }) {
+    const command = program.command(spec.name);
+    command.description(spec.description);
+    (spec.arguments ?? []).forEach((argument)=>{
+        command.addArgument(argument);
+    });
+    (spec.options ?? []).forEach((option)=>{
+        command.addOption(option);
+    });
+    if (spec.action) command.action(async (...args)=>{
+        if (spec.auth && runAuth) await runAuth();
+        await spec.action?.(...args);
+    });
+    (spec.subCommands ?? []).forEach((subCommand)=>{
+        addCommand({
+            program: command,
+            spec: subCommand,
+            runAuth
+        });
+    });
+}
+const logger = {
+    info (...messages) {
+        console.log(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].blue('[INFO]'), ...messages);
+    },
+    success (...messages) {
+        console.log(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].green('[SUCCESS]'), ...messages);
+    },
+    warning (...messages) {
+        console.log(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].yellow('[WARNING]'), ...messages);
+    },
+    error (...messages) {
+        console.error(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].red('[ERROR]'), ...messages);
+    },
+    debug (...messages) {
+        if (process.env.DEBUG) console.log(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].magenta('[DEBUG]'), ...messages);
+    }
+};
+/**
+ * @coze/a-b -> __coze__a_b
+ * @coze-ui/a-b -> __coze_ui__a_b
+ * a-b -> a_b
+ */ function pkgName2RemoteName(pkgName) {
+    const hasScope = pkgName.startsWith('@');
+    const parts = pkgName.split('/');
+    return `${hasScope ? `__${parts[0].slice(1)}__` : parts[0]}${parts.slice(1).join('_')}`.replace(/-/g, '_');
+}
+// @module-federation/rsbuild-plugin only support cjs
+const config_require = (0, __WEBPACK_EXTERNAL_MODULE_node_module__.createRequire)(import.meta.url);
+const pluginModuleFederation = config_require('@module-federation/rsbuild-plugin').pluginModuleFederation;
+const { isEmpty, merge } = __WEBPACK_EXTERNAL_MODULE_lodash__["default"];
+const CONFIG_FILE_NAME = 'ui.config';
+const CONFIG_FILE_EXTNAME = [
+    '.js',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+];
+const CDN_MAP = {
+    boe: '//lf0-fast-deliver-inner.bytedance.net/obj/eden-internal/ibo-lgvj/ljhwZthlaukjlkulzlp/',
+    cn: '//lf3-static.bytednsdoc.com/obj/eden-cn/ibo-lgvj/ljhwZthlaukjlkulzlp/'
+};
+function defineConfig(config) {
+    return config;
+}
+async function loadConfig({ cwd = process.cwd(), path }) {
+    const configFilePath = resolveConfigPath(cwd, path);
+    const { content } = await (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_core__.loadConfig)({
+        cwd: (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(configFilePath),
+        path: configFilePath
+    });
+    content._privateMeta = {
+        configFilePath
+    };
+    return content;
+}
+function getShareRslibConfig(uiConfig, libConfig) {
+    const projectDir = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(uiConfig._privateMeta.configFilePath);
+    const pkgJson = JSON.parse(__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].readFileSync(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, 'package.json'), 'utf-8'));
+    const umdName = pkgName2RemoteName(pkgJson.name);
+    const entries = resolveExports(uiConfig);
+    const tsconfigPath = resolveTsconfigPath(projectDir);
+    const libs = [];
+    const formats = [
+        'cjs',
+        'esm',
+        'umd',
+        'mf'
+    ];
+    Object.entries(entries).forEach(([dist, src])=>{
+        for (const format of formats){
+            // mf should use exposes instead of multiple entries
+            if ('mf' === format && '.' !== dist) continue;
+            const config = {
+                dts: {
+                    bundle: false
+                },
+                format,
+                output: {
+                    distPath: {
+                        root: __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join('dist', format, dist)
+                    }
+                },
+                source: {
+                    tsconfigPath,
+                    entry: {
+                        index: src
+                    }
+                },
+                shims: {
+                    cjs: {
+                        'import.meta.url': true
+                    },
+                    esm: {
+                        __filename: true,
+                        __dirname: true,
+                        require: true
+                    }
+                },
+                // each entry should have unique name
+                umdName: __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(umdName, dist).replace(/\//g, '_')
+            };
+            if ('mf' === format) {
+                // default use boe
+                const cdn = CDN_MAP[process.env.REGION ?? ''] ?? CDN_MAP.boe;
+                const singleton = [
+                    'react',
+                    'react-dom'
+                ];
+                let shared = uiConfig.shared ?? {};
+                if (isEmpty(shared) && null !== uiConfig.shared) for (const type of [
+                    'dependencies',
+                    'peerDependencies'
+                ])Object.entries(pkgJson[type]).forEach(([name])=>{
+                    shared[name] = {
+                        singleton: singleton.includes(name)
+                    };
+                });
+                merge(config, {
+                    output: {
+                        assetPrefix: `${cdn}${__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(`${pkgJson.name}@${pkgJson.version}`, 'dist/mf', dist)}`
+                    },
+                    plugins: [
+                        pluginModuleFederation({
+                            name: umdName,
+                            exposes: entries,
+                            shared
+                        })
+                    ]
+                });
+            } else if ('umd' === format) merge(config, {
+                output: {
+                    minify: true,
+                    injectStyles: true
+                }
+            });
+            libs.push(merge(config, libConfig));
+        }
+    });
+    return merge({
+        lib: libs,
+        plugins: [
+            (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_plugin_react__.pluginReact)(),
+            (0, __WEBPACK_EXTERNAL_MODULE__rsbuild_plugin_less__.pluginLess)()
+        ]
+    }, uiConfig.rslib ?? {}, {
+        _privateMeta: uiConfig._privateMeta
+    });
+}
+function resolveConfigPath(root, customConfig) {
+    if (customConfig) {
+        const customConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path__["default"].isAbsolute(customConfig) ? customConfig : __WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(root, customConfig);
+        if (__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(customConfigPath)) {
+            if (__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].statSync(customConfigPath).isFile()) return customConfigPath;
+            root = customConfigPath;
+        } else throw new Error(`${CONFIG_FILE_NAME} not found in ${customConfigPath}`);
+    }
+    const configFilePath = CONFIG_FILE_EXTNAME.map((extname)=>`${__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(root, CONFIG_FILE_NAME)}${extname}`).find((p)=>__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(p));
+    if (configFilePath) return configFilePath;
+    throw new Error(`${CONFIG_FILE_NAME} not found in ${root}`);
+}
+function resolveTsconfigPath(root) {
+    // Preferred tsconfig.build.json
+    if (__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(root, 'tsconfig.build.json'))) return 'tsconfig.build.json';
+    return 'tsconfig.json';
+}
+function resolveMainEntry(projectDir) {
+    const mainEntry = CONFIG_FILE_EXTNAME.map((extname)=>`index${extname}`).find((e)=>__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].existsSync(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, `src/${e}`)));
+    return mainEntry;
+}
+/**
+ * The `exports` field in `package.json` must adhere to the following format：
+ *
+ * ```
+ * exports: {
+ *   ".": {
+ *     ...
+ *     "src": "./src/index.tsx"
+ *   },
+ *   "./button": {
+ *     ...
+ *     "src": "./src/button/index.tsx"
+ *   }
+ * }
+ * ```
+ */ function resolveExports(uiConfig) {
+    const projectDir = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(uiConfig._privateMeta.configFilePath);
+    const srcEntry = resolveMainEntry(projectDir);
+    if (!srcEntry) throw new Error('entry not found, maybe you forget the "src/index.ts"?');
+    const pkgJson = JSON.parse(__WEBPACK_EXTERNAL_MODULE_node_fs__["default"].readFileSync(__WEBPACK_EXTERNAL_MODULE_node_path__["default"].join(projectDir, 'package.json'), 'utf-8'));
+    let exposes = {};
+    Object.entries(pkgJson.exports ?? {}).forEach(([key, config])=>{
+        if (!config.src) {
+            logger.warning([
+                `exports.${key} does't have "src", the builder will ignore this export.`,
+                `you should add "src" field, such as:\n`,
+                'exports: {\n',
+                `  "${key}": {\n`,
+                '    "src": "./src/index.tsx"\n',
+                '  }\n',
+                '}'
+            ].join(''));
+            return;
+        }
+        // mfplugin doesn't support "./"
+        const k = './' === key ? '.' : key;
+        exposes[k] = config.src;
+    });
+    // use default export
+    if (isEmpty(exposes)) exposes['.'] = `./src/${srcEntry}`;
+    return exposes;
+}
+/* eslint-disable security/detect-non-literal-fs-filename -- ignore */ const buildAction = async (options = {})=>{
+    const uiConfig = await loadConfig({
+        path: options.dir
+    });
+    const projectDir = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)(uiConfig._privateMeta.configFilePath);
+    // esm/cjs/umd/mf
+    const prevCwd = process.cwd();
+    try {
+        process.chdir(projectDir);
+        const rslibConfig = getShareRslibConfig(uiConfig, options.libConfig);
+        await (0, __WEBPACK_EXTERNAL_MODULE__rslib_core__.build)(rslibConfig);
+    } catch (e) {} finally{
+        process.chdir(prevCwd);
+    }
+};
+new __WEBPACK_EXTERNAL_MODULE_commander__.Option('-d, --dir <componentDir>', 'the path of component');
+export { addCommand, buildAction, defineConfig };

package/dist/npm.d.ts

@@ -0,0 +1,28 @@
+import { type TokenSetParameters } from 'openid-client';
+import Config from '@npmcli/config';
+import { type INpmConfig, type BaseConfigData } from './helpers/types';
+import { type Region } from './helpers/constants';
+export interface NpmConfigOptions {
+    projectDir?: string;
+    scope?: string;
+    region?: Region;
+    source?: string;
+}
+export interface ConfigData extends BaseConfigData {
+    region?: Region;
+    source?: string;
+}
+export declare class NpmConfig implements INpmConfig<ConfigData> {
+    private proxy;
+    private config;
+    constructor({ projectDir, scope, region, source }?: NpmConfigOptions);
+    get registryScope(): string;
+    get registryUrl(): string;
+    get registryAuthUrl(): string;
+    get refreshKey(): string;
+    get region(): string;
+    loadConfig(): Promise<ConfigData>;
+    storeToken(tokenSet: TokenSetParameters): Promise<void>;
+    clearToken(): Promise<void>;
+    getProxy(): Config;
+}