@_tc/template-core 0.0.1 → 0.0.2

package/package.json

@@ -1,28 +1,81 @@
 {
   "name": "@_tc/template-core",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A TypeScript Koa framework template - Monorepo root",
   "main": "./index.js",
-  "types": "./index.d.ts",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./cjs/index.js",
+      "types": "./types/index.d.ts"
+    },
+    "./bundler": {
+      "import": "./esm/bundler/index.js",
+      "require": "./cjs/bundler/index.js",
+      "types": "./types/bundler/index.d.ts"
+    },
+    "./fe/main": {
+      "import": "./fe/frontend/src/main.js",
+      "require": "./fe/frontend/src/main.js",
+      "types": "./fe/frontend/src/main.d.ts"
+    },
+    "./fe": {
+      "import": "./fe/frontend/src/index.js",
+      "require": "./fe/frontend/src/index.js",
+      "types": "./fe/frontend/src/index.d.ts"
+    },
+    "./fe/rc": {
+      "import": "./fe/packages/ui/react/index.js",
+      "require": "./fe/packages/ui/react/index.js",
+      "types": "./fe/packages/ui/react/index.d.ts"
+    },
+    "./fe/rc/*": {
+      "import": "./fe/packages/ui/react/*",
+      "require": "./fe/packages/ui/react/*",
+      "types": "./fe/packages/ui/react/*"
+    },
+    "./fe/*": {
+      "import": "./fe/frontend/src/*",
+      "require": "./fe/frontend/src/*",
+      "types": "./fe/frontend/src/*"
+    },
+    "./fe/tailwind_ui.css": "./fe/frontend/src/main.css",
+    "./model": {
+      "types": "./model/index.d.ts"
+    }
+  },
   "dependencies": {
+    "@tailwindcss/vite": "^4.2.4",
     "ajv": "^8.18.0",
-    "knex": "^3.2.3",
+    "chokidar": "^4.0.3",
+    "glob": "^10.3.10",
+    "immer": "^11.1.7",
     "koa-bodyparser": "^4.4.1",
     "koa-compress": "^5.2.1",
-    "koa-nunjucks-2": "^3.0.2",
     "koa-static": "^5.0.0",
     "log4js": "^6.9.1",
     "md5": "^2.3.0",
     "nunjucks": "^3.2.4",
-    "superagent": "^7.1.0"
+    "tailwind": "^4.0.0"
   },
   "peerDependencies": {
     "@types/node": ">=18.0.0",
-    "glob": "^10.3.10",
+    "@vitejs/plugin-react": "6.0.1",
+    "clsx": "^2.1.0",
+    "date-fns": "^3.6.0",
     "koa": "^2.15.0",
-    "koa-nunjucks-2": "^3.0.2",
     "koa-router": "^12.0.1",
-    "lodash": "^4.17.21"
+    "lodash": "^4.17.21",
+    "lucide-react": "^0.468.0",
+    "rc-field-form": "^1.44.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-router-dom": "^6.28.0",
+    "tailwind-merge": "^2.4.0",
+    "vite": "^8.0.0",
+    "xlsx": "^0.18.5",
+    "zustand": "^5.0.0"
   },
   "keywords": [
     "koa",

package/{app → types/app}/controller/base.d.ts

@@ -1,14 +1,12 @@
-import { KoaApp } from "../type";
-import { Ctx } from "../../app/type";
-declare const _default: (app: KoaApp) => {
+import type { Ctx, KoaApp } from "../type";
+declare const getBaseController: (app: KoaApp) => {
     new (): {
         readonly app: KoaApp;
         readonly config: KoaApp["config"];
-        get service(): import("../../packages/core").IService & import("../typings").IServiceAugmented;
+        get service(): import("../../packages/core/index").FrameworkAugment.IServiceAugmented;
         success(ctx: Ctx, data: unknown): void;
         fail(ctx: Ctx, code: number, message: string): void;
         sendData(ctx: Ctx, data?: unknown, code?: number, message?: string | null, status?: number): void;
     };
 };
-export default _default;
-//# sourceMappingURL=base.d.ts.map
+export default getBaseController;

package/types/app/controller/project.d.ts

@@ -0,0 +1,22 @@
+import type { Ctx, KoaApp } from "../type";
+export interface IProjectController {
+    getModelList(ctx: Ctx): Promise<void>;
+    getProjectList(ctx: Ctx): Promise<void>;
+    getProject(ctx: Ctx): Promise<void>;
+    success(ctx: Ctx, data: unknown): void;
+    fail(ctx: Ctx, code: number, message: string): void;
+}
+declare const getProjectController: (app: KoaApp) => {
+    new (): {
+        getModelList: (ctx: Ctx) => Promise<void>;
+        getProjectList: (ctx: Ctx) => Promise<void>;
+        getProject: (ctx: Ctx) => Promise<void>;
+        readonly app: KoaApp;
+        readonly config: KoaApp["config"];
+        get service(): import("../../packages/core/index").FrameworkAugment.IServiceAugmented;
+        success(ctx: Ctx, data: unknown): void;
+        fail(ctx: Ctx, code: number, message: string): void;
+        sendData(ctx: Ctx, data?: unknown, code?: number, message?: string | null, status?: number): void;
+    };
+};
+export default getProjectController;

package/{app → types/app}/controller/view.d.ts

@@ -1,9 +1,7 @@
-import { KoaApp } from "../type";
-import { Ctx } from "../../app/type";
+import type { Ctx, KoaApp } from "../type";
 declare const getViewController: (app: KoaApp) => {
     new (): {
         renderPage(ctx: Ctx): Promise<void>;
     };
 };
 export default getViewController;
-//# sourceMappingURL=view.d.ts.map

package/{app → types/app}/data/signKey.d.ts

@@ -1,2 +1 @@
 export declare const signKey = "sakjdfnkjwjfnfkjkjldljksndf";
-//# sourceMappingURL=signKey.d.ts.map

package/types/app/extend/$fetch.d.ts

@@ -0,0 +1,8 @@
+import type { RequestConfig } from "../../packages/common/http/index";
+import type { KoaApp } from "../type";
+import { FetchAxios } from "../../packages/common/http/index";
+export interface NodeFetch extends FetchAxios {
+    create: (config?: RequestConfig) => FetchAxios;
+}
+declare const _default: (_app: KoaApp) => NodeFetch;
+export default _default;

package/types/app/extend/db.d.ts

@@ -0,0 +1,2 @@
+import type { KoaApp } from "../type";
+export default function getDB(app: KoaApp): Promise<{}>;

package/{app → types/app}/extend/generateErrorMessage.d.ts

@@ -5,4 +5,3 @@ interface ErrorOption {
 }
 declare const _default: () => (message: string, option?: ErrorOption) => never;
 export default _default;
-//# sourceMappingURL=generateErrorMessage.d.ts.map

package/{app → types/app}/extend/logger.d.ts

@@ -1,4 +1,4 @@
-import { KoaApp } from "../type";
+import type { KoaApp } from "../type";
 interface MConsole {
     log: (...args: any[]) => void;
     info: (...args: any[]) => void;
@@ -9,4 +9,3 @@ interface MConsole {
 }
 declare const _default: (app: KoaApp) => Promise<MConsole>;
 export default _default;
-//# sourceMappingURL=logger.d.ts.map

package/{app → types/app}/extend/parsingParamsOnUrl.d.ts

@@ -1,3 +1,2 @@
 declare const _default: () => (urlRules: string, url: string) => Record<string, string> | null;
 export default _default;
-//# sourceMappingURL=parsingParamsOnUrl.d.ts.map

package/{app → types/app}/extend/render-view.d.ts

@@ -1,5 +1,3 @@
-import type { KoaApp } from "../type";
-import type { Ctx } from "../../app/type";
+import type { Ctx, KoaApp } from "../type";
 declare const _default: (app: KoaApp) => (view: string, ctx: Ctx, context?: Record<string, unknown>) => void;
 export default _default;
-//# sourceMappingURL=render-view.d.ts.map

package/{app → types/app}/middleware/api-params-verify.d.ts

@@ -1,6 +1,4 @@
 import type Koa from "koa";
-import { KoaApp } from "../type";
-import { Ctx } from "../../app/type";
+import type { Ctx, KoaApp } from "../type";
 declare const _default: (app: KoaApp) => (ctx: Ctx, next: Koa.Next) => Promise<any>;
 export default _default;
-//# sourceMappingURL=api-params-verify.d.ts.map

package/{app → types/app}/middleware/api-sign-verify.d.ts

@@ -1,6 +1,4 @@
 import type Koa from "koa";
-import { KoaApp } from "../type";
-import { Ctx } from "../../app/type";
+import type { Ctx, KoaApp } from "../type";
 declare const _default: (app: KoaApp) => (ctx: Ctx, next: Koa.Next) => Promise<void>;
 export default _default;
-//# sourceMappingURL=api-sign-verify.d.ts.map

package/types/app/middleware/error-handle.d.ts

@@ -0,0 +1,4 @@
+import type { Ctx, KoaApp } from "../type";
+import type Koa from "koa";
+declare const _default: (app: KoaApp) => (ctx: Ctx, next: Koa.Next) => Promise<void>;
+export default _default;

package/types/app/middleware/project-handler.d.ts

@@ -0,0 +1,4 @@
+import type { Ctx } from "../type";
+import type Koa from "koa";
+declare const _default: () => (ctx: Ctx, next: Koa.Next) => Promise<void>;
+export default _default;

package/{app → types/app}/middleware.d.ts

@@ -1,6 +1,3 @@
-import "../packages/core/index.js";
-import "./typings";
 import type { KoaApp } from "./typings";
 declare const _default: (app: KoaApp) => void;
 export default _default;
-//# sourceMappingURL=middleware.d.ts.map

package/{app/router/view.d.ts → types/app/router/project.d.ts}

@@ -1,5 +1,4 @@
-import { KoaApp } from "../type";
+import type { KoaApp } from "../type";
 import type Router from "koa-router";
 declare const _default: (app: KoaApp, router: Router) => void;
 export default _default;
-//# sourceMappingURL=view.d.ts.map

package/types/app/router/view.d.ts

@@ -0,0 +1,3 @@
+import type { KoaApp, KoaRouter } from "../type";
+declare const _default: (app: KoaApp, router: KoaRouter) => void;
+export default _default;

package/types/app/router-schema/project.d.ts

@@ -0,0 +1,3 @@
+import type { RouterSchemaType } from "./types";
+declare const routerSchema: RouterSchemaType;
+export default routerSchema;

package/types/app/service/base.d.ts

@@ -0,0 +1,9 @@
+import type { KoaApp } from "../type";
+declare const getBaseService: (app: KoaApp) => {
+    new (): {
+        get app(): KoaApp;
+        get config(): KoaApp["config"];
+        get curl(): import("../extend/$fetch").NodeFetch;
+    };
+};
+export default getBaseService;

package/types/app/service/project.d.ts

@@ -0,0 +1,57 @@
+import type { KoaApp } from "../type";
+type LeftMenuType = {};
+type TopMenuType = {};
+export interface ProjectItem {
+    mode: string;
+    homePage: string;
+    icon: string;
+    name: string;
+    desc: string;
+    menuLayout: 'top' | 'left';
+    menu: [
+        {
+            key: string;
+            name: string;
+            menuType: string;
+            subMenu: (LeftMenuType | TopMenuType)[];
+        },
+        {
+            menuType: string;
+            moduleType: string;
+            key: string;
+            name: string;
+            sidebarConfig: {}[];
+        }
+    ];
+    key: string;
+    modelKey: string;
+}
+export interface ModelItem {
+    model: {
+        mode: string;
+        homePage: string;
+        icon: string;
+        name: string;
+        desc: string;
+        menuLayout: string;
+        menu: (LeftMenuType | TopMenuType)[];
+        key: string;
+    };
+    project: Record<string, ProjectItem>;
+}
+declare const getProjectService: (app: KoaApp) => {
+    new (): {
+        getModelList(): Promise<ModelItem[]>;
+        /**
+         *
+         * @param key 不传查所有
+         * @returns
+         */
+        getList: (key?: string) => ProjectItem[];
+        getProject: (projectKey: string) => ProjectItem | null;
+        get app(): KoaApp;
+        get config(): KoaApp["config"];
+        get curl(): import("../extend/$fetch").NodeFetch;
+    };
+};
+export default getProjectService;

package/types/app/type.d.ts

@@ -0,0 +1,5 @@
+export type KoaApp = import('./typings').KoaApp;
+export type KoaRouter = import('./typings').KoaRouter;
+export type Ctx = KoaApp['context'];
+export type ControllerFN<T extends object = object> = (app: KoaApp) => new () => T;
+export type ServiceFN<T extends object = object> = (app: KoaApp) => new () => T;

package/types/app/typings.d.ts

@@ -0,0 +1,43 @@
+import type { FrameworkAugment, KoaApp, KoaAppExtensions, KoaRouter } from "../packages/core/index";
+import { GetInstance } from "typings/type";
+import type { DefaultAppConfig } from "../config/config.default";
+import type getProjectController from "./controller/project";
+import type getViewController from "./controller/view";
+import type getFetch from "./extend/$fetch";
+import type getDB from "./extend/db";
+import type generateErrorMessage from "./extend/generateErrorMessage";
+import type getLogger from "./extend/logger";
+import type parsingParamsOnUrl from "./extend/parsingParamsOnUrl";
+import renderView from "./extend/render-view";
+import type getProjectService from "./service/project";
+type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+declare module '../packages/core/index' {
+    namespace FrameworkAugment {
+        interface IServiceAugmented {
+            project: GetInstance<typeof getProjectService>;
+        }
+        interface IControllerAugmented {
+            project: GetInstance<typeof getProjectController>;
+            view: GetInstance<typeof getViewController>;
+        }
+        interface IExtendsAugmented {
+            db: UnwrapPromise<ReturnType<typeof getDB>>;
+            logger: UnwrapPromise<ReturnType<typeof getLogger>>;
+            generateErrorMessage: ReturnType<typeof generateErrorMessage>;
+            parsingParamsOnUrl: ReturnType<typeof parsingParamsOnUrl>;
+            $fetch: ReturnType<typeof getFetch>;
+            nunjucksEnv: import('nunjucks').Environment;
+            renderView: ReturnType<typeof renderView>;
+        }
+        interface IMiddlewaresAugmented {
+            errorHandle: import('koa').Middleware;
+            apiSignVerify: import('koa').Middleware;
+            apiParamsVerify: import('koa').Middleware;
+            projectHandler: import('koa').Middleware;
+        }
+        interface AppConfigAugmented extends DefaultAppConfig {
+        }
+    }
+}
+export { KoaAppExtensions };
+export type { FrameworkAugment, KoaApp, KoaRouter };

package/types/bundler/defaultAlias.d.ts

@@ -0,0 +1,3 @@
+export {};
+declare const _default: {};
+export default _default;

package/types/bundler/dev.d.ts

@@ -0,0 +1 @@
+export declare function dev(): Promise<void>;

package/types/bundler/index.d.ts

@@ -0,0 +1,2 @@
+import type { BuildFEOptions } from "./state";
+export declare const buildFE: (mode: "dev" | "prod", options?: BuildFEOptions) => void;

package/types/bundler/prod.d.ts

@@ -0,0 +1 @@
+export declare function prod(): Promise<void>;

package/types/bundler/state.d.ts

@@ -0,0 +1,18 @@
+export interface BuildFEOptions {
+    /**
+     * - frame
+     *   - The build output will be placed under node_modules/.../app/public.
+     * - !!!!!!
+     * - run
+     *   - If you are using TypeScript
+     *   - and compiling TS to JS,
+     *   - pay extra attention to whether the compiled output contains the app/public directory.
+     * - Function
+     *   - Maybe you really do not need it.
+     */
+    output?: 'frame' | 'run' | (() => string);
+}
+export declare const buildFESharedState: {
+    options: BuildFEOptions;
+};
+export declare function setBuildFEOptions(options?: BuildFEOptions): void;

package/types/bundler/utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * 寻找 frontend\/**\/*.entry.[j|t]s(x)?
+ * 生成入口
+ */
+export declare function entries(): Record<string, string>;
+export declare function outDir(): string;
+export declare const watchFiles: (callback?: () => Promise<any>) => Promise<void>;
+export declare const VBuildFE: (input: Record<string, string>, OperatingEnv?: "dev" | "prod") => Promise<void>;

package/types/config/config.default.d.ts

@@ -0,0 +1,14 @@
+export interface DefaultAppConfig {
+    frameName: string;
+    port?: number;
+    host?: string;
+    env?: string;
+    apiSignVerify?: {
+        whiteList?: string[];
+    };
+    viewsPath?: string;
+    nunjucks?: import("nunjucks").ConfigureOptions;
+    notFoundRedirectCount: number;
+}
+declare const _default: DefaultAppConfig;
+export default _default;

package/types/index.d.ts

@@ -0,0 +1,28 @@
+import { StartOptions } from "./packages/core/index";
+import type Router from "koa-router";
+import "./app/typings";
+import { MOmit } from "./typings/type";
+export type { FrameworkAugment, KoaApp } from "./packages/core/index";
+export type { ControllerFN, Ctx, ServiceFN } from "./app/type";
+export type { Router };
+export declare const serverStart: (options?: MOmit<StartOptions, "frameBaseDir">) => import("./packages/core/index").KoaApp;
+export declare const baseFn: {
+    baseControllerFn: (app: import("./app/type").KoaApp) => {
+        new (): {
+            readonly app: import("./app/type").KoaApp;
+            readonly config: import("./app/type").KoaApp["config"];
+            get service(): import("./packages/core/index").FrameworkAugment.IServiceAugmented;
+            success(ctx: import(".").Ctx, data: unknown): void;
+            fail(ctx: import(".").Ctx, code: number, message: string): void;
+            sendData(ctx: import(".").Ctx, data?: unknown, code?: number, message?: string | null, status?: number): void;
+        };
+    };
+    baseServiceFn: (app: import("./app/type").KoaApp) => {
+        new (): {
+            get app(): import("./app/type").KoaApp;
+            get config(): import("./app/type").KoaApp["config"];
+            get curl(): import("./app/extend/$fetch").NodeFetch;
+        };
+    };
+};
+export { default as modelLoader } from "./packages/core/loader/model";

package/types/packages/common/LRUCache.d.ts

@@ -0,0 +1 @@
+export { LRUCache } from "./cache/LRUCache";

package/types/packages/common/array/index.d.ts

@@ -0,0 +1,6 @@
+export declare function toArray<T>(value: readonly T[]): T[];
+export declare function toArray<T>(value: T | null | undefined): T[];
+export declare const compact: <T>(items: readonly (T | null | undefined)[]) => T[];
+export declare const uniqueBy: <T, K extends PropertyKey>(items: readonly T[], getKey: (item: T) => K) => T[];
+export declare const groupBy: <T, K extends PropertyKey>(items: readonly T[], getKey: (item: T) => K) => Record<K, T[]>;
+export declare const chunk: <T>(items: readonly T[], size: number) => T[][];

package/types/packages/common/cache/LRUCache.d.ts

@@ -0,0 +1,12 @@
+export declare class LRUCache<T> {
+    private readonly limit;
+    private readonly data;
+    constructor(limit: number);
+    get size(): number;
+    has(k: string): boolean;
+    get(k: string): NonNullable<T> | undefined;
+    set(k: string, v: T): void;
+    push(k: string, v: T): void;
+    private deleteFirstKey;
+    private updateSorting;
+}

package/types/packages/common/cache/index.d.ts

@@ -0,0 +1 @@
+export * from "./LRUCache";

package/types/packages/common/guards/index.d.ts

@@ -0,0 +1,8 @@
+import type { Dictionary, Maybe } from "../types";
+export declare const isNil: <T>(value: Maybe<T>) => value is null | undefined;
+export declare const isNonNullable: <T>(value: T) => value is NonNullable<T>;
+export declare const isString: (value: unknown) => value is string;
+export declare const isNumber: (value: unknown) => value is number;
+export declare const isBoolean: (value: unknown) => value is boolean;
+export declare const isFunction: <TArgs extends unknown[], TResult>(value: unknown) => value is (...args: TArgs) => TResult;
+export declare const isPlainObject: (value: unknown) => value is Dictionary;

package/types/packages/common/http/index.d.ts

@@ -0,0 +1,89 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+export type HttpHeaders = Record<string, string>;
+export type RequestCredentials = 'omit' | 'same-origin' | 'include';
+export type RequestCache = 'default' | 'force-cache' | 'no-cache' | 'no-store' | 'only-if-cached' | 'reload';
+export type RequestRedirect = 'error' | 'follow' | 'manual';
+export type ReferrerPolicy = '' | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+export interface HeadersLike {
+    forEach(callback: (value: string, key: string) => void): void;
+    has(name: string): boolean;
+    set(name: string, value: string): void;
+}
+export interface ProgressEventLike {
+    loaded?: number;
+    total?: number;
+    lengthComputable?: boolean;
+}
+export type RequestBodyLike = string | ArrayBuffer | ArrayBufferView | object;
+export interface RequestConfig<D = unknown> {
+    url?: string;
+    method?: HttpMethod;
+    baseURL?: string;
+    headers?: HttpHeaders;
+    params?: Record<string, string | number | boolean | undefined | null>;
+    data?: D;
+    timeout?: number;
+    signal?: unknown;
+    credentials?: RequestCredentials;
+    cache?: RequestCache;
+    redirect?: RequestRedirect;
+    referrer?: string;
+    referrerPolicy?: ReferrerPolicy;
+    transformRequest?: ((data: D, headers: HeadersLike) => D | RequestBodyLike) | ((data: D, headers: HeadersLike) => D | RequestBodyLike)[];
+    transformResponse?: ((data: unknown) => unknown) | ((data: unknown) => unknown)[];
+    validateStatus?: (status: number) => boolean;
+    onUploadProgress?: (progress: ProgressEventLike) => void;
+    onDownloadProgress?: (progress: ProgressEventLike) => void;
+}
+export interface ResponseConfig<T = unknown, D = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: HttpHeaders;
+    config: RequestConfig<D>;
+    request?: unknown;
+}
+export interface AxiosError<T = unknown, D = unknown> extends Error {
+    config: RequestConfig<D>;
+    code?: string;
+    request?: unknown;
+    response?: ResponseConfig<T, D>;
+    isAxiosError: boolean;
+}
+interface InterceptorHandler<V> {
+    fulfilled?: (value: V) => V | Promise<V>;
+    rejected?: (error: unknown) => unknown;
+    id: number;
+}
+declare class InterceptorManager<V> {
+    private handlers;
+    private nextId;
+    use(onFulfilled?: (value: V) => V | Promise<V>, onRejected?: (error: unknown) => unknown): number;
+    eject(id: number): void;
+    clear(): void;
+    getHandlers(): InterceptorHandler<V>[];
+}
+export declare class FetchAxios {
+    defaults: RequestConfig;
+    interceptors: {
+        request: InterceptorManager<RequestConfig<unknown>>;
+        response: InterceptorManager<ResponseConfig<unknown, unknown>>;
+    };
+    constructor(config?: RequestConfig);
+    private request;
+    private applyRequestInterceptors;
+    private applyResponseInterceptors;
+    private applyResponseErrorInterceptors;
+    private _doRequest;
+    private createError;
+    get<T = unknown, D = unknown>(url: string, config?: RequestConfig<D>): Promise<ResponseConfig<T, D>>;
+    post<T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>): Promise<ResponseConfig<T, D>>;
+    put<T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>): Promise<ResponseConfig<T, D>>;
+    patch<T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>): Promise<ResponseConfig<T, D>>;
+    delete<T = unknown, D = unknown>(url: string, config?: RequestConfig<D>): Promise<ResponseConfig<T, D>>;
+    head<T = unknown, D = unknown>(url: string, config?: RequestConfig<D>): Promise<ResponseConfig<T, D>>;
+    options<T = unknown, D = unknown>(url: string, config?: RequestConfig<D>): Promise<ResponseConfig<T, D>>;
+}
+export declare const axios: FetchAxios;
+export declare const createInstance: (defaultConfig: RequestConfig) => FetchAxios;
+export default FetchAxios;