• Version 0.5.14
  • Published
  • 34.7 kB
  • 11 dependencies
  • MIT license


npm i umi-types
yarn add umi-types
pnpm add umi-types


Type definitions for umi.



Type Aliases



interface IAdd

interface IAdd<T, U = {}> {}

    call signature

    (fn: IAddFunc<T, U> | T | T[]): void;

      interface IAddFunc

      interface IAddFunc<T, U> {}

        call signature

        (memo: T[], args: U): T | T[];

        interface IAddImportOpts

        interface IAddImportOpts {}

          property source

          source: string;
          • Parameter source

            : Path to module

            Parameter specifier

            : Module name with import, can be ignored

          property specifier

          specifier?: string;

            interface IAfterDevServerFunc

            interface IAfterDevServerFunc {}

              call signature

              (args: { server: any; devServerPort: number }): void;

                interface IApi

                interface IApi {}

                  property addBlockUIResource

                  addBlockUIResource: IAdd<object>;

                    property addEntryCode

                    addEntryCode: IAdd<string>;

                      property addEntryCodeAhead

                      addEntryCodeAhead: IAdd<string>;

                        property addEntryImport

                        addEntryImport: IAdd<IAddImportOpts>;

                          property addEntryImportAhead

                          addEntryImportAhead: IAdd<IAddImportOpts>;

                            property addEntryPolyfillImports

                            addEntryPolyfillImports: IAdd<IAddImportOpts>;

                              property addHTMLHeadScript

                              addHTMLHeadScript: IAdd<object, { route?: IRoute }>;
                                addHTMLLink: IAdd<object, { route?: IRoute }>;

                                  property addHTMLMeta

                                  addHTMLMeta: IAdd<object, { route?: IRoute }>;

                                    property addHTMLScript

                                    addHTMLScript: IAdd<object, { route?: IRoute }>;

                                      property addHTMLStyle

                                      addHTMLStyle: IAdd<object, { route?: IRoute }>;

                                        property addMiddleware

                                        addMiddleware: IAdd<IMiddlewareFunction>;

                                          property addMiddlewareAfterMock

                                          addMiddlewareAfterMock: IAdd<IMiddlewareFunction>;

                                            property addMiddlewareAhead

                                            addMiddlewareAhead: IAdd<IMiddlewareFunction>;

                                              property addMiddlewareBeforeMock

                                              addMiddlewareBeforeMock: IAdd<IMiddlewareFunction>;

                                                property addPageWatcher

                                                addPageWatcher: IAdd<string>;

                                                  property addRendererWrapperWithComponent

                                                  addRendererWrapperWithComponent: IAdd<string, () => string>;

                                                    property addRendererWrapperWithModule

                                                    addRendererWrapperWithModule: IAdd<string>;

                                                      property addRouterImport

                                                      addRouterImport: IAdd<IAddImportOpts>;

                                                        property addRouterImportAhead

                                                        addRouterImportAhead: IAdd<IAddImportOpts>;

                                                          property addRuntimePlugin

                                                          addRuntimePlugin: IAdd<string>;

                                                            property addRuntimePluginKey

                                                            addRuntimePluginKey: IAdd<string>;

                                                              property addUIPlugin

                                                              addUIPlugin: IAdd<string>;

                                                                property addUmiExports

                                                                addUmiExports: IAdd<object>;

                                                                  property addVersionInfo

                                                                  addVersionInfo: IAdd<string>;

                                                                    property afterDevServer

                                                                    afterDevServer: IAfterDevServer;

                                                                      property API_TYPE

                                                                      API_TYPE: typeof API_TYPE;
                                                                      • System level variable

                                                                      property applyPlugins

                                                                      applyPlugins: IApplyPlugins;

                                                                        property beforeBlockWriting

                                                                        beforeBlockWriting: IBeforeBlockWriting;

                                                                          property beforeDevServer

                                                                          beforeDevServer: IBeforeDevServer;
                                                                          • Event class API

                                                                          property chainWebpackConfig

                                                                          chainWebpackConfig: IChangeWebpackConfig<IWebpackChainConfig, IAFWebpackConfig>;

                                                                            property changePluginOption

                                                                            changePluginOption: IChangePluginOption;

                                                                              property compatDirname

                                                                              compatDirname: ICompatDirname;

                                                                                property config

                                                                                config: IConfig;

                                                                                  property cwd

                                                                                  cwd: string;

                                                                                    property debug

                                                                                    debug: ILog;

                                                                                      property findCSS

                                                                                      findCSS: IFind;

                                                                                        property findJS

                                                                                        findJS: IFind;

                                                                                          property getRouteComponents

                                                                                          getRouteComponents: IGetRouteComponents;

                                                                                            property getRoutes

                                                                                            getRoutes: IGetRoutes;

                                                                                              property locale

                                                                                              locale: any;

                                                                                                property log

                                                                                                log: { [key in DefaultMethods]: ILog<any> };
                                                                                                • Tool class API

                                                                                                property modifyAFWebpackOpts

                                                                                                modifyAFWebpackOpts: IModify<IAFWebpackConfig>;

                                                                                                  property modifyBlockUIResources

                                                                                                  modifyBlockUIResources: IModify<object[]>;

                                                                                                    property modifyDefaultConfig

                                                                                                    modifyDefaultConfig: IModify<object>;
                                                                                                    • Application class API

                                                                                                    property modifyEntryHistory

                                                                                                    modifyEntryHistory: IModify<string>;

                                                                                                      property modifyEntryRender

                                                                                                      modifyEntryRender: IModify<string>;

                                                                                                        property modifyHTMLChunks

                                                                                                        modifyHTMLChunks: IModify<string[], { route?: IRoute }>;

                                                                                                          property modifyHTMLContext

                                                                                                          modifyHTMLContext: IModify<object, { route?: IRoute }>;

                                                                                                            property modifyHTMLWithAST

                                                                                                            modifyHTMLWithAST: IModifyHTMLWithAST;

                                                                                                              property modifyPublicPathStr

                                                                                                              modifyPublicPathStr: IModify<string>;

                                                                                                                property modifyRouteComponent

                                                                                                                modifyRouteComponent: IModify<string, IModifyRouteComponentArgs>;

                                                                                                                  property modifyRouterRootComponent

                                                                                                                  modifyRouterRootComponent: IModify<string>;

                                                                                                                    property modifyRoutes

                                                                                                                    modifyRoutes: IModify<IRoute[]>;

                                                                                                                      property modifyWebpackConfig

                                                                                                                      modifyWebpackConfig: IModify<IWebpack.Configuration>;

                                                                                                                        property onBuildFail

                                                                                                                        onBuildFail: IOnBuildFail;

                                                                                                                          property onBuildSuccess

                                                                                                                          onBuildSuccess: IOnBuildSuccess;

                                                                                                                            property onBuildSuccessAsync

                                                                                                                            onBuildSuccessAsync: IOnBuildSuccessAsync;

                                                                                                                              property onDevCompileDone

                                                                                                                              onDevCompileDone: IOnDevCompileDone;

                                                                                                                                property onGenerateFiles

                                                                                                                                onGenerateFiles: IOnGenerateFiles;

                                                                                                                                  property onHTMLRebuild

                                                                                                                                  onHTMLRebuild: IOnHTMLRebuild;

                                                                                                                                    property onOptionChange

                                                                                                                                    onOptionChange: IOnOptionChange;

                                                                                                                                      property onPatchRoute

                                                                                                                                      onPatchRoute: IOnPatchRoute;

                                                                                                                                        property onPrintUmiError

                                                                                                                                        onPrintUmiError: onPrintUmiError;

                                                                                                                                          property onRouteChange

                                                                                                                                          onRouteChange: (callback: () => void) => void;

                                                                                                                                            property onStart

                                                                                                                                            onStart: IOnStart;

                                                                                                                                              property onStartAsync

                                                                                                                                              onStartAsync: IEventAsync;

                                                                                                                                                property onUISocket

                                                                                                                                                onUISocket: IOnUISocket;

                                                                                                                                                  property paths

                                                                                                                                                  paths: {
                                                                                                                                                  cwd: string;
                                                                                                                                                  outputPath: string;
                                                                                                                                                  absOutputPath: string;
                                                                                                                                                  absNodeModulesPath: string;
                                                                                                                                                  pagesPath: string;
                                                                                                                                                  absPagesPath: string;
                                                                                                                                                  absSrcPath: string;
                                                                                                                                                  tmpDirPath: string;
                                                                                                                                                  absTmpDirPath: string;

                                                                                                                                                    property pkg

                                                                                                                                                    pkg: IPkg;

                                                                                                                                                      property rebuildHTML

                                                                                                                                                      rebuildHTML: IReDo<void>;

                                                                                                                                                        property rebuildTmpFiles

                                                                                                                                                        rebuildTmpFiles: IReDo<string>;

                                                                                                                                                          property refreshBrowser

                                                                                                                                                          refreshBrowser: IReDo<void>;

                                                                                                                                                            property register

                                                                                                                                                            register: IRegister;
                                                                                                                                                            • System level API

                                                                                                                                                            property registerCommand

                                                                                                                                                            registerCommand: IRegisterCommand;

                                                                                                                                                              property registerMethod

                                                                                                                                                              registerMethod: IRegisterMethod;

                                                                                                                                                                property registerPlugin

                                                                                                                                                                registerPlugin: IRegisterPlugin;

                                                                                                                                                                  property relativeToTmp

                                                                                                                                                                  relativeToTmp: IRelativeToTmp;

                                                                                                                                                                    property restart

                                                                                                                                                                    restart: IReDo<string>;

                                                                                                                                                                      property routes

                                                                                                                                                                      routes: IRoute[];

                                                                                                                                                                        property service

                                                                                                                                                                        service: any;

                                                                                                                                                                          property UmiError

                                                                                                                                                                          UmiError: any;

                                                                                                                                                                            property webpackConfig

                                                                                                                                                                            webpackConfig: IWebpack.Configuration;

                                                                                                                                                                              property winPath

                                                                                                                                                                              winPath: IWinPath;

                                                                                                                                                                                property writeTmpFile

                                                                                                                                                                                writeTmpFile: IWriteTmpFile;

                                                                                                                                                                                  interface IApplyPluginsOpts

                                                                                                                                                                                  interface IApplyPluginsOpts {}

                                                                                                                                                                                    property args

                                                                                                                                                                                    args?: any;

                                                                                                                                                                                      property initialValue

                                                                                                                                                                                      initialValue?: any;

                                                                                                                                                                                        interface IBeforeBlockWritingFunc

                                                                                                                                                                                        interface IBeforeBlockWritingFunc {}

                                                                                                                                                                                          call signature

                                                                                                                                                                                          (args: { service: any; sourcePath: string; blockPath: string }): void;

                                                                                                                                                                                            interface IBeforeDevServerFunc

                                                                                                                                                                                            interface IBeforeDevServerFunc {}
                                                                                                                                                                                            • Event class API

                                                                                                                                                                                            call signature

                                                                                                                                                                                            (args: { server: any }): void;

                                                                                                                                                                                              interface IBlockDependencies

                                                                                                                                                                                              interface IBlockDependencies {}

                                                                                                                                                                                                property conflicts

                                                                                                                                                                                                conflicts: [string, string, string][];

                                                                                                                                                                                                  property devConflicts

                                                                                                                                                                                                  devConflicts: [string, string, string][];

                                                                                                                                                                                                    property devLacks

                                                                                                                                                                                                    devLacks: [string, string][];

                                                                                                                                                                                                      property lacks

                                                                                                                                                                                                      lacks: [string, string][];

                                                                                                                                                                                                        interface IChangeWebpackConfig

                                                                                                                                                                                                        interface IChangeWebpackConfig<T, U> {}
                                                                                                                                                                                                        • Application class API

                                                                                                                                                                                                        call signature

                                                                                                                                                                                                        (fn: IChangeWebpackConfigFunc<T, U>): void;

                                                                                                                                                                                                          interface IChangeWebpackConfigFunc

                                                                                                                                                                                                          interface IChangeWebpackConfigFunc<T, U> {}

                                                                                                                                                                                                            call signature

                                                                                                                                                                                                            (webpackConfig: T, AFWebpack: { webpack: U }): T | void;

                                                                                                                                                                                                              interface ICommandOpts

                                                                                                                                                                                                              interface ICommandOpts {}

                                                                                                                                                                                                                property description

                                                                                                                                                                                                                description?: string;
                                                                                                                                                                                                                • Parameter description

                                                                                                                                                                                                                  : Description displayed when running umi help

                                                                                                                                                                                                                  Parameter details

                                                                                                                                                                                                                  : Details displayed when running umi help [YOUR_COMMAND]

                                                                                                                                                                                                                  Parameter hide

                                                                                                                                                                                                                  : Hide your command in umi help

                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                  : Options displayed when running umi help [YOUR_COMMAND]

                                                                                                                                                                                                                  Parameter usage

                                                                                                                                                                                                                  : Usage displayed when running umi help [YOUR_COMMAND]

                                                                                                                                                                                                                  Parameter webpack

                                                                                                                                                                                                                  : Whether to initialize webpack config

                                                                                                                                                                                                                property details

                                                                                                                                                                                                                details?: string;

                                                                                                                                                                                                                  property hide

                                                                                                                                                                                                                  hide?: boolean;

                                                                                                                                                                                                                    property options

                                                                                                                                                                                                                    options?: object;

                                                                                                                                                                                                                      property usage

                                                                                                                                                                                                                      usage?: string;

                                                                                                                                                                                                                        property webpack

                                                                                                                                                                                                                        webpack?: boolean;

                                                                                                                                                                                                                          interface IConfig

                                                                                                                                                                                                                          interface IConfig extends IAFWebpackConfig {}

                                                                                                                                                                                                                            property base

                                                                                                                                                                                                                            base?: string;

                                                                                                                                                                                                                              property block

                                                                                                                                                                                                                              block?: object;

                                                                                                                                                                                                                                property chainWebpack

                                                                                                                                                                                                                                chainWebpack?: IChangeWebpackConfigFunc<IWebpackChainConfig, IAFWebpackConfig>;

                                                                                                                                                                                                                                  property context

                                                                                                                                                                                                                                  context?: object;

                                                                                                                                                                                                                                    property disableRedirectHoist

                                                                                                                                                                                                                                    disableRedirectHoist?: boolean;

                                                                                                                                                                                                                                      property dva

                                                                                                                                                                                                                                      dva?: any;

                                                                                                                                                                                                                                        property exportStatic

                                                                                                                                                                                                                                        exportStatic?: boolean | IExportStaticOpts;

                                                                                                                                                                                                                                          property history

                                                                                                                                                                                                                                          history?: 'browser' | 'hash' | 'memory';

                                                                                                                                                                                                                                            property locale

                                                                                                                                                                                                                                            locale?: any;

                                                                                                                                                                                                                                              property mock

                                                                                                                                                                                                                                              mock?: IMockOpts;

                                                                                                                                                                                                                                                property mountElementId

                                                                                                                                                                                                                                                mountElementId?: string;

                                                                                                                                                                                                                                                  property outputPath

                                                                                                                                                                                                                                                  outputPath?: string;

                                                                                                                                                                                                                                                    property plugins

                                                                                                                                                                                                                                                    plugins?: IPlugin[];

                                                                                                                                                                                                                                                      property routes

                                                                                                                                                                                                                                                      routes?: IRoute[] | null;

                                                                                                                                                                                                                                                        property runtimePublicPath

                                                                                                                                                                                                                                                        runtimePublicPath?: boolean | string;

                                                                                                                                                                                                                                                          property singular

                                                                                                                                                                                                                                                          singular?: boolean;

                                                                                                                                                                                                                                                            property ssr

                                                                                                                                                                                                                                                            ssr?: IExportSSROpts;

                                                                                                                                                                                                                                                              property targets

                                                                                                                                                                                                                                                              targets?: {
                                                                                                                                                                                                                                                              [key: string]: number;

                                                                                                                                                                                                                                                                property treeShaking

                                                                                                                                                                                                                                                                treeShaking?: boolean;

                                                                                                                                                                                                                                                                  interface IMiddlewareFunction

                                                                                                                                                                                                                                                                  interface IMiddlewareFunction {}

                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                    (req: any, res: any, next: any): void;

                                                                                                                                                                                                                                                                      interface IModify

                                                                                                                                                                                                                                                                      interface IModify<T, U = {}> {}

                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                        (fn: IModifyFunc<T, U> | T): void;

                                                                                                                                                                                                                                                                          interface IModifyCommandFunc

                                                                                                                                                                                                                                                                          interface IModifyCommandFunc {}

                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                            (opts: IModifyCommandFuncOpts): IModifyCommandFuncOpts;

                                                                                                                                                                                                                                                                              interface IModifyCommandFuncOpts

                                                                                                                                                                                                                                                                              interface IModifyCommandFuncOpts {}

                                                                                                                                                                                                                                                                                property args

                                                                                                                                                                                                                                                                                args?: any;

                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                    interface IModifyFunc

                                                                                                                                                                                                                                                                                    interface IModifyFunc<T, U> {}

                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                      (memo: T, args: U): T | T;

                                                                                                                                                                                                                                                                                      interface IModifyHelpInfoOpts

                                                                                                                                                                                                                                                                                      interface IModifyHelpInfoOpts {}

                                                                                                                                                                                                                                                                                        property commands

                                                                                                                                                                                                                                                                                        commands: {
                                                                                                                                                                                                                                                                                        [commandName: string]: {
                                                                                                                                                                                                                                                                                        opts: {
                                                                                                                                                                                                                                                                                        hide: boolean;
                                                                                                                                                                                                                                                                                        options: {
                                                                                                                                                                                                                                                                                        [key: string]: string;

                                                                                                                                                                                                                                                                                          property scriptName

                                                                                                                                                                                                                                                                                          scriptName: string;

                                                                                                                                                                                                                                                                                            interface IModifyHTMLWithASTFunc

                                                                                                                                                                                                                                                                                            interface IModifyHTMLWithASTFunc {}

                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                              ($: CheerioStatic, args: IModifyHTMLWithASTArgs): CheerioStatic;

                                                                                                                                                                                                                                                                                                interface IOnBuildFailFunc

                                                                                                                                                                                                                                                                                                interface IOnBuildFailFunc {}

                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                  (args: { stats: IWebpack.Stats[]; err: Error }): void;

                                                                                                                                                                                                                                                                                                    interface IOnBuildSuccessFunc

                                                                                                                                                                                                                                                                                                    interface IOnBuildSuccessFunc {}

                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                      (args: { stats: IWebpack.Stats[] }): void;

                                                                                                                                                                                                                                                                                                        interface IOnDevCompileDoneFunc

                                                                                                                                                                                                                                                                                                        interface IOnDevCompileDoneFunc {}

                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                          (args: { isFirstCompile: boolean; stats: IWebpack.Stats }): void;

                                                                                                                                                                                                                                                                                                            interface IOnGenerateFilesFunc

                                                                                                                                                                                                                                                                                                            interface IOnGenerateFilesFunc {}

                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                              (args: { isRebuild?: boolean }): void;

                                                                                                                                                                                                                                                                                                                interface IOnOptionChangeFunc

                                                                                                                                                                                                                                                                                                                interface IOnOptionChangeFunc<T = any> {}

                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                  (newOpts: T): void;

                                                                                                                                                                                                                                                                                                                    interface IOnPatchRouteFunc

                                                                                                                                                                                                                                                                                                                    interface IOnPatchRouteFunc {}

                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                      (args: { route: IRoute }): void;

                                                                                                                                                                                                                                                                                                                        interface IOnUISocket

                                                                                                                                                                                                                                                                                                                        interface IOnUISocket {}

                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                          (fn: IOnUISocketFunc): void;

                                                                                                                                                                                                                                                                                                                            interface IOnUISocketFunc

                                                                                                                                                                                                                                                                                                                            interface IOnUISocketFunc {}

                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                              (args: {
                                                                                                                                                                                                                                                                                                                              action: IAction;
                                                                                                                                                                                                                                                                                                                              send: ISend;
                                                                                                                                                                                                                                                                                                                              success: ISuccess<{}>;
                                                                                                                                                                                                                                                                                                                              failure: IFailure<{}>;
                                                                                                                                                                                                                                                                                                                              log: IUiLog;
                                                                                                                                                                                                                                                                                                                              }): void;

                                                                                                                                                                                                                                                                                                                                interface IPkg

                                                                                                                                                                                                                                                                                                                                interface IPkg {}

                                                                                                                                                                                                                                                                                                                                  property dependencies

                                                                                                                                                                                                                                                                                                                                  dependencies?: {
                                                                                                                                                                                                                                                                                                                                  [prop: string]: string;

                                                                                                                                                                                                                                                                                                                                    property devDependencies

                                                                                                                                                                                                                                                                                                                                    devDependencies?: {
                                                                                                                                                                                                                                                                                                                                    [prop: string]: string;

                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                      name?: string;

                                                                                                                                                                                                                                                                                                                                        property version

                                                                                                                                                                                                                                                                                                                                        version?: string;

                                                                                                                                                                                                                                                                                                                                          interface IPluginMethod

                                                                                                                                                                                                                                                                                                                                          interface IPluginMethod {}

                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                            (opts: IPluginMethodOpts, ...args: any[]): any;
                                                                                                                                                                                                                                                                                                                                            • Parameter opts

                                                                                                                                                                                                                                                                                                                                              : Includes args passed in from applyPlugins and memo

                                                                                                                                                                                                                                                                                                                                              Parameter args

                                                                                                                                                                                                                                                                                                                                              : Arguments passed in from other plug-ins when they call this method

                                                                                                                                                                                                                                                                                                                                            interface IPluginMethodOpts

                                                                                                                                                                                                                                                                                                                                            interface IPluginMethodOpts {}

                                                                                                                                                                                                                                                                                                                                              property args

                                                                                                                                                                                                                                                                                                                                              args?: any;

                                                                                                                                                                                                                                                                                                                                                property memo

                                                                                                                                                                                                                                                                                                                                                memo?: any;
                                                                                                                                                                                                                                                                                                                                                • Parameter args

                                                                                                                                                                                                                                                                                                                                                  : Come from applyPlugins(, { args: YOUR_ARGS })

                                                                                                                                                                                                                                                                                                                                                interface IRegisterConfigFunc

                                                                                                                                                                                                                                                                                                                                                interface IRegisterConfigFunc {}

                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                  (api: IApi): IRegisterConfigOpts;

                                                                                                                                                                                                                                                                                                                                                    interface IRegisterConfigOpts

                                                                                                                                                                                                                                                                                                                                                    interface IRegisterConfigOpts<T = any> {}

                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                                      • Parameter name

                                                                                                                                                                                                                                                                                                                                                        : Name of your configuration

                                                                                                                                                                                                                                                                                                                                                        Parameter validate

                                                                                                                                                                                                                                                                                                                                                        : Verify that the value of configuration is valid

                                                                                                                                                                                                                                                                                                                                                        Parameter onChange

                                                                                                                                                                                                                                                                                                                                                        : Callback when the value of configuration changes

                                                                                                                                                                                                                                                                                                                                                      property onChange

                                                                                                                                                                                                                                                                                                                                                      onChange?: (newConfig: IConfig, oldConfig: IConfig) => void;

                                                                                                                                                                                                                                                                                                                                                        property validate

                                                                                                                                                                                                                                                                                                                                                        validate?: (value: T) => void;

                                                                                                                                                                                                                                                                                                                                                          interface IRegisterMethodOpts

                                                                                                                                                                                                                                                                                                                                                          interface IRegisterMethodOpts {}

                                                                                                                                                                                                                                                                                                                                                            property apply

                                                                                                                                                                                                                                                                                                                                                            apply?: IPluginMethod;

                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                              type?: API_TYPE;
                                                                                                                                                                                                                                                                                                                                                              • Choose one of type and apply. View more at

                                                                                                                                                                                                                                                                                                                                                              interface IRegisterPluginOpts

                                                                                                                                                                                                                                                                                                                                                              interface IRegisterPluginOpts {}
                                                                                                                                                                                                                                                                                                                                                              • System level API

                                                                                                                                                                                                                                                                                                                                                              property apply

                                                                                                                                                                                                                                                                                                                                                              apply: any;

                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                id: string;

                                                                                                                                                                                                                                                                                                                                                                  property opts

                                                                                                                                                                                                                                                                                                                                                                  opts?: object;

                                                                                                                                                                                                                                                                                                                                                                    interface IRoute

                                                                                                                                                                                                                                                                                                                                                                    interface IRoute {}

                                                                                                                                                                                                                                                                                                                                                                      property component

                                                                                                                                                                                                                                                                                                                                                                      component?: ReactNode;

                                                                                                                                                                                                                                                                                                                                                                        property path

                                                                                                                                                                                                                                                                                                                                                                        path?: string;

                                                                                                                                                                                                                                                                                                                                                                          property redirect

                                                                                                                                                                                                                                                                                                                                                                          redirect?: string;

                                                                                                                                                                                                                                                                                                                                                                            property routes

                                                                                                                                                                                                                                                                                                                                                                            routes?: IRoute[];

                                                                                                                                                                                                                                                                                                                                                                              property Routes

                                                                                                                                                                                                                                                                                                                                                                              Routes?: string[];

                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                  interface MultiStats

                                                                                                                                                                                                                                                                                                                                                                                  interface MultiStats {}

                                                                                                                                                                                                                                                                                                                                                                                    property hash

                                                                                                                                                                                                                                                                                                                                                                                    hash: string;

                                                                                                                                                                                                                                                                                                                                                                                      property stats

                                                                                                                                                                                                                                                                                                                                                                                      stats: IWebpack.Stats[];

                                                                                                                                                                                                                                                                                                                                                                                        Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                        type IFailure

                                                                                                                                                                                                                                                                                                                                                                                        type IFailure<T = object> = (payload: T) => void;

                                                                                                                                                                                                                                                                                                                                                                                          type IPlugin

                                                                                                                                                                                                                                                                                                                                                                                          type IPlugin<T = any> = string | [string, T];

                                                                                                                                                                                                                                                                                                                                                                                            type ISend

                                                                                                                                                                                                                                                                                                                                                                                            type ISend = (action: IAction<{}>) => void;

                                                                                                                                                                                                                                                                                                                                                                                              type ISuccess

                                                                                                                                                                                                                                                                                                                                                                                              type ISuccess<T = object> = (payload: T) => void;

                                                                                                                                                                                                                                                                                                                                                                                                type IUiApi

                                                                                                                                                                                                                                                                                                                                                                                                type IUiApi = IUi.IApi;

                                                                                                                                                                                                                                                                                                                                                                                                  type IUiLog

                                                                                                                                                                                                                                                                                                                                                                                                  type IUiLog = (type: IUiLogType, payload: string) => void;


                                                                                                                                                                                                                                                                                                                                                                                                    namespace IUi

                                                                                                                                                                                                                                                                                                                                                                                                    namespace IUi {}

                                                                                                                                                                                                                                                                                                                                                                                                      class IApiClass

                                                                                                                                                                                                                                                                                                                                                                                                      class IApiClass {}


                                                                                                                                                                                                                                                                                                                                                                                                        constructor(service: IService);

                                                                                                                                                                                                                                                                                                                                                                                                          property addDashboard

                                                                                                                                                                                                                                                                                                                                                                                                          addDashboard: IAddDashboard;

                                                                                                                                                                                                                                                                                                                                                                                                            property addLocales

                                                                                                                                                                                                                                                                                                                                                                                                            addLocales: IAddLocales;
                                                                                                                                                                                                                                                                                                                                                                                                            • add plugin locales { zh-CN: {}, en-US: {} }

                                                                                                                                                                                                                                                                                                                                                                                                            property addPanel

                                                                                                                                                                                                                                                                                                                                                                                                            addPanel: IAddPanel;
                                                                                                                                                                                                                                                                                                                                                                                                            • add plugin Panel

                                                                                                                                                                                                                                                                                                                                                                                                            property bigfish

                                                                                                                                                                                                                                                                                                                                                                                                            readonly bigfish: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                            • whether Bigfish

                                                                                                                                                                                                                                                                                                                                                                                                            property callRemote

                                                                                                                                                                                                                                                                                                                                                                                                            callRemote: ICallRemote<unknown, unknown>;

                                                                                                                                                                                                                                                                                                                                                                                                              property ConfigForm

                                                                                                                                                                                                                                                                                                                                                                                                              ConfigForm: FC<IConfigFormProps>;
                                                                                                                                                                                                                                                                                                                                                                                                              • React Config Form Component

                                                                                                                                                                                                                                                                                                                                                                                                              property connect

                                                                                                                                                                                                                                                                                                                                                                                                              connect: any;

                                                                                                                                                                                                                                                                                                                                                                                                                property currentProject

                                                                                                                                                                                                                                                                                                                                                                                                                currentProject: ICurrentProject;
                                                                                                                                                                                                                                                                                                                                                                                                                • currentProject

                                                                                                                                                                                                                                                                                                                                                                                                                property debug

                                                                                                                                                                                                                                                                                                                                                                                                                readonly debug: Debugger;
                                                                                                                                                                                                                                                                                                                                                                                                                • debug for client

                                                                                                                                                                                                                                                                                                                                                                                                                property detectLanguage

                                                                                                                                                                                                                                                                                                                                                                                                                detectLanguage: IDetectLanguage;

                                                                                                                                                                                                                                                                                                                                                                                                                  property detectNpmClients

                                                                                                                                                                                                                                                                                                                                                                                                                  detectNpmClients: () => Promise<string[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                    property DirectoryForm

                                                                                                                                                                                                                                                                                                                                                                                                                    DirectoryForm: FC<IDirectoryForm>;

                                                                                                                                                                                                                                                                                                                                                                                                                      property event

                                                                                                                                                                                                                                                                                                                                                                                                                      event: NodeJS.EventEmitter;
                                                                                                                                                                                                                                                                                                                                                                                                                      • event

                                                                                                                                                                                                                                                                                                                                                                                                                      property Field

                                                                                                                                                                                                                                                                                                                                                                                                                      Field: FC<IFieldProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Antd Form Field

                                                                                                                                                                                                                                                                                                                                                                                                                      property getBasicUI

                                                                                                                                                                                                                                                                                                                                                                                                                      getBasicUI: IGetBasicUI;
                                                                                                                                                                                                                                                                                                                                                                                                                      • get Plugin UI Service

                                                                                                                                                                                                                                                                                                                                                                                                                      property getCwd

                                                                                                                                                                                                                                                                                                                                                                                                                      getCwd: IGetCwd;

                                                                                                                                                                                                                                                                                                                                                                                                                        property getDashboard

                                                                                                                                                                                                                                                                                                                                                                                                                        getDashboard: IGetDashboard;
                                                                                                                                                                                                                                                                                                                                                                                                                        • get dashboard list

                                                                                                                                                                                                                                                                                                                                                                                                                        property getLocale

                                                                                                                                                                                                                                                                                                                                                                                                                        getLocale: IGetLocale;
                                                                                                                                                                                                                                                                                                                                                                                                                        • get current locale: zh-CN or en-US

                                                                                                                                                                                                                                                                                                                                                                                                                        property getSearchParams

                                                                                                                                                                                                                                                                                                                                                                                                                        getSearchParams: IGetSearchParams;
                                                                                                                                                                                                                                                                                                                                                                                                                        • get location search params

                                                                                                                                                                                                                                                                                                                                                                                                                        property getSharedDataDir

                                                                                                                                                                                                                                                                                                                                                                                                                        getSharedDataDir: IGetSharedDataDir;
                                                                                                                                                                                                                                                                                                                                                                                                                        • get the current project's temp dir path

                                                                                                                                                                                                                                                                                                                                                                                                                        property hideLogPanel

                                                                                                                                                                                                                                                                                                                                                                                                                        hideLogPanel: IHideLogPanel;
                                                                                                                                                                                                                                                                                                                                                                                                                        • close footer log panel

                                                                                                                                                                                                                                                                                                                                                                                                                        property hideMini

                                                                                                                                                                                                                                                                                                                                                                                                                        hideMini: IHideMini;
                                                                                                                                                                                                                                                                                                                                                                                                                        • hide Mini Modal

                                                                                                                                                                                                                                                                                                                                                                                                                        property hooks

                                                                                                                                                                                                                                                                                                                                                                                                                        readonly hooks: Hooks;
                                                                                                                                                                                                                                                                                                                                                                                                                        • React hooks for UI development

                                                                                                                                                                                                                                                                                                                                                                                                                        property intl

                                                                                                                                                                                                                                                                                                                                                                                                                        intl: IIntl<PickIntl>;
                                                                                                                                                                                                                                                                                                                                                                                                                        • intl, formatMessage

                                                                                                                                                                                                                                                                                                                                                                                                                        property launchEditor

                                                                                                                                                                                                                                                                                                                                                                                                                        launchEditor: ILaunchEditor;

                                                                                                                                                                                                                                                                                                                                                                                                                          property listenRemote

                                                                                                                                                                                                                                                                                                                                                                                                                          listenRemote: IListenRemote;

                                                                                                                                                                                                                                                                                                                                                                                                                            property mini

                                                                                                                                                                                                                                                                                                                                                                                                                            readonly mini: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                            • can use as vars

                                                                                                                                                                                                                                                                                                                                                                                                                            property modifyBasicUI

                                                                                                                                                                                                                                                                                                                                                                                                                            modifyBasicUI: IModifyBasicUI;

                                                                                                                                                                                                                                                                                                                                                                                                                              property moment

                                                                                                                                                                                                                                                                                                                                                                                                                              moment: any;
                                                                                                                                                                                                                                                                                                                                                                                                                              • moment

                                                                                                                                                                                                                                                                                                                                                                                                                              property notify

                                                                                                                                                                                                                                                                                                                                                                                                                              notify: INotify;
                                                                                                                                                                                                                                                                                                                                                                                                                              • system notify

                                                                                                                                                                                                                                                                                                                                                                                                                              property redirect

                                                                                                                                                                                                                                                                                                                                                                                                                              redirect: IRedirect;
                                                                                                                                                                                                                                                                                                                                                                                                                              • redirect

                                                                                                                                                                                                                                                                                                                                                                                                                              property registerModel

                                                                                                                                                                                                                                                                                                                                                                                                                              registerModel: IRegisterModel;
                                                                                                                                                                                                                                                                                                                                                                                                                              • register dva model Panel

                                                                                                                                                                                                                                                                                                                                                                                                                              property request

                                                                                                                                                                                                                                                                                                                                                                                                                              readonly request: any;
                                                                                                                                                                                                                                                                                                                                                                                                                              • umi-request

                                                                                                                                                                                                                                                                                                                                                                                                                              property send

                                                                                                                                                                                                                                                                                                                                                                                                                              send: ISend;

                                                                                                                                                                                                                                                                                                                                                                                                                                property service

                                                                                                                                                                                                                                                                                                                                                                                                                                service: IService;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property setActionPanel

                                                                                                                                                                                                                                                                                                                                                                                                                                  setActionPanel: ISetActionPanel;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property showLogPanel

                                                                                                                                                                                                                                                                                                                                                                                                                                    showLogPanel: IShowLogPanel;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • open footer log panel

                                                                                                                                                                                                                                                                                                                                                                                                                                    property showMini

                                                                                                                                                                                                                                                                                                                                                                                                                                    showMini: IShowMini;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • show Mini Modal

                                                                                                                                                                                                                                                                                                                                                                                                                                    property StepForm

                                                                                                                                                                                                                                                                                                                                                                                                                                    StepForm: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property Terminal

                                                                                                                                                                                                                                                                                                                                                                                                                                      Terminal: FC<ITerminalProps>;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Terminal Component

                                                                                                                                                                                                                                                                                                                                                                                                                                      property TwoColumnPanel

                                                                                                                                                                                                                                                                                                                                                                                                                                      TwoColumnPanel: FC<ITwoColumnPanel>;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • React Two Column Panel Layout

                                                                                                                                                                                                                                                                                                                                                                                                                                      method getContext

                                                                                                                                                                                                                                                                                                                                                                                                                                      getContext: () => Context<IContext>;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • react component context

                                                                                                                                                                                                                                                                                                                                                                                                                                      method isMini

                                                                                                                                                                                                                                                                                                                                                                                                                                      isMini: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • current is in Mini version

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FuseOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FuseOptions<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                        property caseSensitive

                                                                                                                                                                                                                                                                                                                                                                                                                                        caseSensitive?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property distance

                                                                                                                                                                                                                                                                                                                                                                                                                                          distance?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property findAllMatches

                                                                                                                                                                                                                                                                                                                                                                                                                                            findAllMatches?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property getFn

                                                                                                                                                                                                                                                                                                                                                                                                                                              getFn?: (obj: any, path: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                id?: keyof T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property includeMatches

                                                                                                                                                                                                                                                                                                                                                                                                                                                  includeMatches?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property includeScore

                                                                                                                                                                                                                                                                                                                                                                                                                                                    includeScore?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property keys

                                                                                                                                                                                                                                                                                                                                                                                                                                                      keys?: (keyof T)[] | T[keyof T] | { name: keyof T; weight: number }[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property location

                                                                                                                                                                                                                                                                                                                                                                                                                                                        location?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property matchAllTokens

                                                                                                                                                                                                                                                                                                                                                                                                                                                          matchAllTokens?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property maxPatternLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                            maxPatternLength?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property minMatchCharLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                              minMatchCharLength?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property shouldSort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                shouldSort?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property sortFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sortFn?: (a: { score: number }, b: { score: number }) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property threshold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    threshold?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tokenize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tokenize?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tokenSeparator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tokenSeparator?: RegExp;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property verbose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          verbose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Hooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Hooks extends UmiHooks {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IAction<T = object, K = void> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property keep

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                keep?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onMessage?: (data: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onProgress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onProgress?: (data: K) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property payload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      payload?: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IAnalyze

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IAnalyze {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property gtag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            gtag: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Tracert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Tracert: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IBasicUI

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IBasicUI {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property 'create.project.button'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'create.project.button': ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • create Project Button ReactNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property 'project.pages'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'project.pages': {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** create step */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  create: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • project pages current step

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dashboard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dashboard: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** sider Footer */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  siderFooter: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Dashboard extend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property feedback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  feedback: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** Image src */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  src: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** Image width */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  width: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /** Image height */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  height: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • feedback Image

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property helpDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  helpDoc: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • helpDoc link

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  logo: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • framework logo ReactNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property logo_remote

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  logo_remote: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • framework logo image url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • framework name, Umi / Bigfish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IConfigFormProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IConfigFormProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property edit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    edit: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • edit config interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property enableToc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enableToc?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • enable Toc, default false

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fuseOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fuseOpts?: FuseOptions<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Search fuse options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property list

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    list: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • list config interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    title: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • config title in the top

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IContext {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property basicUI

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      basicUI: IBasicUI;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property currentProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        currentProject?: ICurrentProject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property formatMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          formatMessage: typeof intl.formatMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property FormattedMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FormattedMessage: typeof intl.FormattedMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hideLogPanel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hideLogPanel: IHideLogPanel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • close footer log panel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isMini

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isMini: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property locale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                locale: ILang;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property service

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  service: IService;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property setLocale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setLocale: typeof intl.setLocale;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property setTheme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setTheme: (theme: ITheme) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property showLogPanel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        showLogPanel: IShowLogPanel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • open footer log panel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        theme: ITheme;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IconType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IconType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property rotate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rotate?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              theme?: 'filled' | 'outlined' | 'twoTone';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property twoToneColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                twoToneColor?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ICurrentProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ICurrentProject {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property created_at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      created_at?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        key?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property npmClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            npmClient?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property opened_at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opened_at?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                path?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property taobaoSpeedUp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  taobaoSpeedUp?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IDashboard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IDashboard {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property backgroundColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      backgroundColor?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • icon background color, default #459BF7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property colClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      colClassName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • col wrapper container className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      content: ReactNode | ReactNode[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        description: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • card description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enable?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property icon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          icon: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • icon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          key: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • uniq dashboard Card id, required

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property right

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          right?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • card Right button

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          title: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • card title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IDirectoryForm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IDirectoryForm {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onChange?: (value: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • path / cwd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IFieldLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IFieldLabel {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                description: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • label description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                link: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • description detail link

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                title: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • label title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IFieldProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IFieldProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property defaultValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  defaultValue?: IValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • defaultValue(only using in object field type)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property form

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  form: object;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • antd form ins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  label: string | ReactNode | IFieldLabel;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • antd label, if object using

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • form field name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Array Select options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  size?: 'default' | 'small' | 'large';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • size, default

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: IConfigTypes;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • formItem type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • same as antd Form.Item props

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ILaunchEditorParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ILaunchEditorParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property editor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    editor?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property lineNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      lineNumber?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: LaunchEditorTypes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface INotifyParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface INotifyParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            message: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              open?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • URL to open on click

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property subtitle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              subtitle?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The amount of seconds before the notification closes. Takes precedence over wait if both are defined.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                title: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type?: 'error' | 'info' | 'warning' | 'success';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • notify type, default info

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IPanel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IPanel extends IRoute {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property actions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    actions?: IPanelAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property beta

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      beta?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        component: FunctionComponent | ComponentClass;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property headerTitle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headerTitle?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • header title, default use title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property icon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          icon: IconType | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property renderTitle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              renderTitle?: (title: string) => ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • custom title Component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IPanelConfigAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IPanelConfigAction {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property action

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                action?: IAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onClick?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    title: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type?: 'default' | 'primary';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IService {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property basicUI

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          basicUI: Partial<IBasicUI>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property configSections

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            configSections: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property dashboard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dashboard: IDashboard[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property locales

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                locales: ILocale[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property panels

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  panels: IPanel[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IStepFormProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IStepFormProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      children: ReactElement<IStepItemForm>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onFinish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onFinish: (values: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IStepItemForm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IStepItemForm {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property active

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              active: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property currentStep

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                currentStep: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property goNext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  goNext: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property goPrev

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    goPrev: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property handleFinish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      handleFinish: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property index

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IStepItemProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IStepItemProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              children: ReactElement<Partial<IStepItemForm>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ITerminalProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ITerminalProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      config?: ITerminalOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property defaultValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultValue?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • defaultValue in Terminal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onInit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onInit?: (ins: XTerminal, fitAddon: any) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • terminal init event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onResize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onResize?: (ins: XTerminal) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property terminalClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        terminalClassName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          title?: ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Terminal title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ITwoColumnPanel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ITwoColumnPanel {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property disableLeftOverflow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                disableLeftOverflow?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property disableRightOverflow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  disableRightOverflow?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property sections

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sections: Array<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    title: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    icon: string | ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    description: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    component: FunctionComponent<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enum CONFIG_TYPES

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enum CONFIG_TYPES {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'string' = 'string',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'string[]' = 'string[]',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'boolean' = 'boolean',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'object' = 'object',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'object[]' = 'object[]',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'list' = 'list',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'textarea' = 'textarea',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'any' = 'any',

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member 'any'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'any' = 'any'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member 'boolean'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'boolean' = 'boolean'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member 'list'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'list' = 'list'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member 'object'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'object' = 'object'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member 'object[]'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'object[]' = 'object[]'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member 'string'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'string' = 'string'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member 'string[]'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'string[]' = 'string[]'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member 'textarea'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'textarea' = 'textarea'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum LOCALES

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum LOCALES {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'zh-CN' = '中文',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'en-US' = 'English',

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member 'en-US'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'en-US' = 'English'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member 'zh-CN'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'zh-CN' = '中文'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enum THEME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enum THEME {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'dark' = 'dark',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'light' = 'light',

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member 'dark'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'dark' = 'dark'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member 'light'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'light' = 'light'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IAddDashboard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IAddDashboard = (dashboard: IDashboard | IDashboard[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type IAddLocales

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type IAddLocales = (locale: ILocale) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type IAddPanel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type IAddPanel = (panel: IPanel) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IApi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IApi = InstanceType<typeof IApiClass>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IApiActionFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IApiActionFactory<P = {}, K = {}> = (action: IAction<P, K>) => Promise<K>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ICallRemote

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ICallRemote<T = unknown, P = unknown> = IApiActionFactory<T, P>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type IConfigTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type IConfigTypes = keyof typeof CONFIG_TYPES;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IConnect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IConnect = typeof connect;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IDebug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IDebug = Debugger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type IDetectLanguage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type IDetectLanguage = () => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type IEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type IEvent = NodeJS.EventEmitter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IFormatMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IFormatMessage = typeof intl.formatMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IGetBasicUI

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IGetBasicUI = () => IBasicUI;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IGetCwd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IGetCwd = () => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type IGetDashboard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type IGetDashboard = () => IDashboard[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IGetLocale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IGetLocale = () => ILang;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IGetSearchParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IGetSearchParams = () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type IGetSharedDataDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type IGetSharedDataDir = () => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type IHideLogPanel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type IHideLogPanel = () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IHideMini

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IHideMini = () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IIntl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IIntl<T = PickIntl> = { [key in keyof T]: T[key] } & typeof intl.formatMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ILang

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ILang = keyof typeof LOCALES;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ILaunchEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ILaunchEditor = (params: ILaunchEditorParams) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IListenRemote

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IListenRemote = IApiActionFactory<{}, () => void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ILocale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ILocale = { [x in ILang]: Locale };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ILodash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ILodash = typeof lodash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type IMini

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type IMini = () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IModifyBasicUI

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IModifyBasicUI = (memo: Partial<IBasicUI>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IMoment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IMoment = typeof moment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type INotify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type INotify = (params: INotifyParams) => void | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type IPanelAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type IPanelAction = (IPanelConfigAction | ReactNode | FC)[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IRedirect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IRedirect = (url: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IRegisterModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IRegisterModel = (model: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ISend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ISend = IApiActionFactory<{}, void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ISetActionPanel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ISetActionPanel = (action: SetFactory<IPanelAction>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IShowLogPanel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IShowLogPanel = () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IShowMini

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type IShowMini = () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IStepForm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IStepForm = FC<IStepFormProps> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              StepItem: FC<IStepItemProps>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ITerminal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ITerminal = XTerminal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ITheme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ITheme = keyof typeof THEME;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IValue = string | object | boolean | string[] | object[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type LaunchEditorTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type LaunchEditorTypes = 'project' | 'config';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Locale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Locale = { [key in string]: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PickIntl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PickIntl = Pick<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          typeof intl,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'FormattedDate'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'FormattedTime'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'FormattedRelative'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'FormattedNumber'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'FormattedPlural'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'FormattedMessage'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'FormattedHTMLMessage'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'formatMessage'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'formatHTMLMessage'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'formatDate'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'formatTime'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'formatRelative'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'formatNumber'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'formatPlural'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SetFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SetFactory<T> = ((state: T) => T) | T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UmiHooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UmiHooks = typeof hooks;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Package Files (3)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dependencies (11)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No peer dependencies.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                To add a badge like this badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You may also use to create a custom badge linking to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <a href=""><img src="" alt=""></a>