@_tc/template-core 0.0.1-bate.6 → 0.0.1-bate.60

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

@@ -0,0 +1,55 @@
+import type { KoaApp } from "../type";
+export type DBValue = unknown;
+export type SQLiteValue = string | number | bigint | null | Uint8Array;
+export type SQLiteParams = SQLiteValue[] | Record<string, SQLiteValue>;
+export interface DBDataOptions {
+    namespace?: string;
+}
+export interface ListDBDataOptions extends DBDataOptions {
+    limit?: number;
+    offset?: number;
+}
+export interface DBDataRecord<T = DBValue> {
+    key: string;
+    value: T;
+    namespace: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface DBRunResult {
+    changes: number;
+    lastInsertRowid: number | bigint;
+}
+export interface FrameworkDB {
+    dbPath: string;
+    getDBConnection: () => unknown;
+    /**
+     * 仅用于固定 SQL，例如建表或迁移。不要拼接用户输入。
+     */
+    execDB: (sql: string) => void;
+    /**
+     * 执行写入 SQL。用户输入必须通过 params 参数绑定，不要拼接到 sql 字符串中。
+     */
+    runDB: (sql: string, params?: SQLiteParams) => DBRunResult;
+    /**
+     * 查询多行数据。用户输入必须通过 params 参数绑定，不要拼接到 sql 字符串中。
+     */
+    queryDB: <T extends object = Record<string, unknown>>(sql: string, params?: SQLiteParams) => T[];
+    /**
+     * 查询单行数据。用户输入必须通过 params 参数绑定，不要拼接到 sql 字符串中。
+     */
+    getDBFirst: <T extends object = Record<string, unknown>>(sql: string, params?: SQLiteParams) => T | undefined;
+    transactionDB: <T>(handler: (db: FrameworkDB) => T) => T;
+    getDBData: <T = DBValue>(key: string, options?: DBDataOptions) => T | undefined;
+    getDBDataRecord: <T = DBValue>(key: string, options?: DBDataOptions) => DBDataRecord<T> | undefined;
+    setDBData: <T = DBValue>(key: string, value: T, options?: DBDataOptions) => DBRunResult;
+    hasDBData: (key: string, options?: DBDataOptions) => boolean;
+    deleteDBData: (key: string, options?: DBDataOptions) => boolean;
+    listDBData: <T = DBValue>(options?: ListDBDataOptions) => DBDataRecord<T>[];
+    countDBData: (options?: DBDataOptions) => number;
+    clearDBData: (options?: DBDataOptions) => number;
+    closeDB: () => void;
+}
+export type DB = FrameworkDB;
+export type DBFactory = (app: KoaApp) => DB | Promise<DB>;
+export default function getDB(app: KoaApp): FrameworkDB;

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

@@ -0,0 +1,7 @@
+interface ErrorOption {
+    status?: number;
+    code?: string | number;
+    showError?: boolean;
+}
+declare const _default: () => (message: string, option?: ErrorOption) => never;
+export default _default;

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

@@ -0,0 +1,11 @@
+import type { KoaApp } from "../type";
+interface MConsole {
+    log: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    debug: (...args: any[]) => void;
+    trace: (...args: any[]) => void;
+}
+declare const _default: (app: KoaApp) => Promise<MConsole>;
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: () => (urlRules: string, url: string) => Record<string, string> | null;
+export default _default;

package/types/app/extend/render-view.d.ts

@@ -0,0 +1,7 @@
+import type { Ctx, KoaApp } from "../type";
+/**
+ * 挂载模板资源地址 默认是 public/dist 目录
+ *
+ */
+declare const _default: (app: KoaApp) => (view: string, ctx: Ctx, context?: Record<string, unknown>) => void;
+export default _default;

package/types/app/middleware.d.ts

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

package/types/app/middlewares/api-params-verify.d.ts

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

package/types/app/middlewares/api-sign-verify.d.ts

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

package/types/app/middlewares/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/middlewares/project-handler.d.ts

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

package/types/app/middlewares/request-parameter-parsing.d.ts

@@ -0,0 +1,7 @@
+/**
+ * - 统一处理请求参数获取
+ * - 除了params  因为params 必须经过router才会有
+ * - 而当前中间件是在 router之前追加，router params 仍然从 ctx.params 获取
+ */
+declare const requestParameterParsing: (app: import("../../packages/core/index").KoaApp) => (ctx: import("app/type").Ctx, next: import("koa").Next) => Promise<void>;
+export default requestParameterParsing;

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

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

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,34 @@
+import type Koa from "koa";
+import type Router from "koa-router";
+import type { IncomingHttpHeaders } from "http";
+import type { ParsedUrlQuery } from "querystring";
+export type KoaApp = import('./typings').KoaApp;
+export type KoaRouter = import('./typings').KoaRouter;
+export type CtxParams = Router.IRouterParamContext['params'];
+export interface CtxReqData {
+    /**
+     * URL query 参数。
+     */
+    query: ParsedUrlQuery;
+    /**
+     * bodyparser 解析后的请求 body。
+     */
+    body: unknown;
+    /**
+     * 原始请求 headers。
+     */
+    headers: IncomingHttpHeaders;
+    /**
+     * 便捷合并层：当前中间件会按 query -> body 的顺序合并。
+     * 字段有冲突时，后面的来源会覆盖前面的来源；需要精确来源时请使用 query/body/headers。
+     */
+    data: Record<string, unknown>;
+}
+export type Ctx = Router.RouterContext<Koa.DefaultState, Koa.DefaultContext> & {
+    params: CtxParams;
+    reqData?: CtxReqData;
+};
+export type MiddlewareFN = (app: KoaApp) => (ctx: Ctx, next: Koa.Next) => Promise<void>;
+export type RouterFN = (app: KoaApp, router: KoaRouter) => void;
+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,46 @@
+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 getCrypto from "./extend/crypto";
+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 {
+            crypto: ReturnType<typeof getCrypto>;
+            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;
+            requestParameterParsing: import('koa').Middleware;
+            projectHandler: import('koa').Middleware;
+        }
+        interface AppConfigAugmented extends Partial<DefaultAppConfig> {
+        }
+    }
+}
+export { KoaAppExtensions };
+export type { FrameworkAugment, KoaApp, KoaRouter };

package/types/bundler/buildBE.d.ts

@@ -0,0 +1,13 @@
+import type { Alias } from "vite";
+import type { BuildEntriesConfig, BuildEntriesResult, BuildFormat } from "../scripts/vite-build/types";
+export type BuildBEAlias = Record<string, string> | Alias[];
+export type BuildBEFormat = BuildFormat;
+export type BuildBEOptions = Omit<BuildEntriesConfig, 'input' | 'format' | 'outDir' | 'rootDir' | 'alias'> & {
+    rootDir?: string;
+    input?: string[];
+    outDir?: string;
+    format?: BuildBEFormat | BuildBEFormat[];
+    alias?: BuildBEAlias;
+};
+export type BuildBEResult = BuildEntriesResult;
+export declare function buildBE(options?: BuildBEOptions): Promise<BuildBEResult>;

package/types/bundler/defaultAlias.d.ts

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

package/types/bundler/defaultRouteGuard.d.ts

@@ -0,0 +1,2 @@
+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,4 @@
+import type { BuildFEOptions } from "./state";
+export { buildBE } from "./buildBE";
+export type { BuildBEAlias, BuildBEFormat, BuildBEOptions, BuildBEResult } from "./buildBE";
+export declare const buildFE: (mode: "dev" | "prod", options?: BuildFEOptions) => Promise<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,71 @@
+export interface DefaultSQLiteConfig {
+    path?: string;
+    filename?: string;
+}
+export interface DefaultDBConfig {
+    /**
+     * SQLite 数据库文件路径。相对路径会基于业务项目 baseDir 解析。
+     */
+    path?: string;
+    /**
+     * SQLite 数据库文件路径，作用同 path。
+     */
+    filename?: string;
+    /**
+     * 兼容旧式或直观命名，作用同 path。
+     */
+    sqlitePath?: string;
+    /**
+     * SQLite 子配置。传字符串时表示数据库文件路径。
+     */
+    sqlite?: string | DefaultSQLiteConfig;
+}
+export interface DefaultAppConfig {
+    frameName: string;
+    port?: number;
+    host?: string;
+    env?: string;
+    /**
+     * 框架默认数据库配置。默认使用 SQLite。
+     */
+    db?: string | DefaultDBConfig;
+    /**
+     * SQLite 数据库路径或配置。等价于 db.sqlite。
+     */
+    sqlite?: string | DefaultSQLiteConfig;
+    signKey: string;
+    apiSignVerify?: {
+        whiteList?: string[];
+    };
+    viewsPath?: string;
+    nunjucks?: import('nunjucks').ConfigureOptions;
+    notFoundRedirectCount?: number;
+    /**
+     * 登陆验证相关
+     */
+    auth?: {
+        /**
+         * 短token 获取的key
+         * @default 'Authorization'
+         */
+        ATKey?: string;
+        /**
+         * 长token 获取的key
+         * @default 'RT'
+         */
+        RTKey?: string;
+    };
+}
+declare const _default: {
+    frameName: string;
+    signKey: string;
+    apiSignVerify: {
+        whiteList: never[];
+    };
+    auth: {
+        ATKey: string;
+        RTKey: string;
+    };
+    notFoundRedirectCount: number;
+};
+export default _default;

package/types/index.d.ts

@@ -0,0 +1,30 @@
+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 { CryptoExtend, CryptoHashAlgorithm, HmacSignOptions, SignedPayloadOptions, VerifySignedPayloadOptions, } from "./app/extend/crypto";
+export type { DB, DBDataOptions, DBDataRecord, DBFactory, DBRunResult, FrameworkDB, ListDBDataOptions, SQLiteParams, SQLiteValue, } from "./app/extend/db";
+export type { ControllerFN, Ctx, MiddlewareFN, RouterFN, ServiceFN } from "./app/type";
+export type { Router };
+export declare const serverStart: (options?: MOmit<StartOptions, "frameBaseDir">) => Promise<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;