umi-types

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

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

source: string;

specifier?: string;

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

addBlockUIResource: IAdd<object>;

addEntryCode: IAdd<string>;

addEntryCodeAhead: IAdd<string>;

addEntryImport: IAdd<IAddImportOpts>;

addEntryImportAhead: IAdd<IAddImportOpts>;

addEntryPolyfillImports: IAdd<IAddImportOpts>;

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

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

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

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

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

addMiddleware: IAdd<IMiddlewareFunction>;

addMiddlewareAfterMock: IAdd<IMiddlewareFunction>;

addMiddlewareAhead: IAdd<IMiddlewareFunction>;

addMiddlewareBeforeMock: IAdd<IMiddlewareFunction>;

addPageWatcher: IAdd<string>;

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

addRendererWrapperWithModule: IAdd<string>;

addRouterImport: IAdd<IAddImportOpts>;

addRouterImportAhead: IAdd<IAddImportOpts>;

addRuntimePlugin: IAdd<string>;

addRuntimePluginKey: IAdd<string>;

addUIPlugin: IAdd<string>;

addUmiExports: IAdd<object>;

addVersionInfo: IAdd<string>;

afterDevServer: IAfterDevServer;

API_TYPE: typeof API_TYPE;

applyPlugins: IApplyPlugins;

beforeBlockWriting: IBeforeBlockWriting;

beforeDevServer: IBeforeDevServer;

chainWebpackConfig: IChangeWebpackConfig<IWebpackChainConfig, IAFWebpackConfig>;

changePluginOption: IChangePluginOption;

compatDirname: ICompatDirname;

config: IConfig;

cwd: string;

debug: ILog;

findCSS: IFind;

findJS: IFind;

getRouteComponents: IGetRouteComponents;

getRoutes: IGetRoutes;

locale: any;

log: { [key in DefaultMethods]: ILog<any> };

modifyAFWebpackOpts: IModify<IAFWebpackConfig>;

modifyBlockUIResources: IModify<object[]>;

modifyDefaultConfig: IModify<object>;

modifyEntryHistory: IModify<string>;

modifyEntryRender: IModify<string>;

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

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

modifyHTMLWithAST: IModifyHTMLWithAST;

modifyPublicPathStr: IModify<string>;

modifyRouteComponent: IModify<string, IModifyRouteComponentArgs>;

modifyRouterRootComponent: IModify<string>;

modifyRoutes: IModify<IRoute[]>;

modifyWebpackConfig: IModify<IWebpack.Configuration>;

onBuildFail: IOnBuildFail;

onBuildSuccess: IOnBuildSuccess;

onBuildSuccessAsync: IOnBuildSuccessAsync;

onDevCompileDone: IOnDevCompileDone;

onGenerateFiles: IOnGenerateFiles;

onHTMLRebuild: IOnHTMLRebuild;

onOptionChange: IOnOptionChange;

onPatchRoute: IOnPatchRoute;

onPrintUmiError: onPrintUmiError;

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

onStart: IOnStart;

onStartAsync: IEventAsync;

onUISocket: IOnUISocket;

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

pkg: IPkg;

rebuildHTML: IReDo<void>;

rebuildTmpFiles: IReDo<string>;

refreshBrowser: IReDo<void>;

register: IRegister;

registerCommand: IRegisterCommand;

registerMethod: IRegisterMethod;

registerPlugin: IRegisterPlugin;

relativeToTmp: IRelativeToTmp;

restart: IReDo<string>;

routes: IRoute[];

service: any;

UmiError: any;

webpackConfig: IWebpack.Configuration;

winPath: IWinPath;

writeTmpFile: IWriteTmpFile;

args?: any;

initialValue?: any;

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

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

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

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

devLacks: [string, string][];

lacks: [string, string][];

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

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

description?: string;

details?: string;

hide?: boolean;

options?: object;

usage?: string;

webpack?: boolean;

base?: string;

block?: object;

chainWebpack?: IChangeWebpackConfigFunc<IWebpackChainConfig, IAFWebpackConfig>;

context?: object;

disableRedirectHoist?: boolean;

dva?: any;

exportStatic?: boolean | IExportStaticOpts;

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

locale?: any;

mock?: IMockOpts;

mountElementId?: string;

outputPath?: string;

plugins?: IPlugin[];

routes?: IRoute[] | null;

runtimePublicPath?: boolean | string;

singular?: boolean;

ssr?: IExportSSROpts;

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

treeShaking?: boolean;

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

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

(opts: IModifyCommandFuncOpts): IModifyCommandFuncOpts;

args?: any;

name: string;

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

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

scriptName: string;

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

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

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

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

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

(newOpts: T): void;

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

(fn: IOnUISocketFunc): void;

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

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

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

name?: string;

version?: string;

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

args?: any;

memo?: any;

(api: IApi): IRegisterConfigOpts;

name: string;

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

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

apply?: IPluginMethod;

type?: API_TYPE;

apply: any;

id: string;

opts?: object;

component?: ReactNode;

path?: string;

redirect?: string;

routes?: IRoute[];

Routes?: string[];

[key: string]: any;

hash: string;

stats: IWebpack.Stats[];