declare type UtilityFunction<T = any, K = any> = (...args: T[]) => K | typeof Function;
declare type UtilityObject = Record<any, any>;
interface UtilityClass {
    new <T>(...items: T[]): T[];
}
interface ClassConstructor {
    new <T>(...items: T[]): T[];
}

/**
 * Class Container
 * @description zh-CN 容器类，所有需要注入到核心容器的方法或者类都源于此
 * @author SunnyXu <xy@ztes.com>
 */
declare class Container {
    protected static instance: Container | null;
    protected instances: Map<any, any>;
    protected bindings: Record<string, any>;
    protected aliases: Record<string, any>;
    /**
     * method bind
     * @description zh-CN 绑定方法
     * @param abstract
     * @param concrete
     */
    bind(abstract: string | string[], concrete: any): void;
    /**
     * make 创建类的实例/获取对象 create instance/object
     * @param abstract
     * @param params
     * @param shared
     */
    make(abstract: string, params?: Record<string, any> | [], shared?: boolean): any;
    /**
     * makeClass 创建类
     * @param name
     * @param Executor
     * @param params
     * @param shared
     */
    protected makeClass(name: string, Executor: ClassConstructor, params: unknown, shared?: boolean): any;
    /**
     * makeFunc 创建函数
     * @param name
     * @param executor
     * @param params
     * @param shared
     * @protected
     */
    protected makeFunc(name: string, executor: CallableFunction, params: unknown, shared?: boolean): any;
    /**
     * has as existence
     * 是否存在标识 existence 的别名
     * @param {String} name
     */
    has(name: string): boolean;
    /**
     * existence 存在标识
     * @param {String} name
     */
    existence(name: string): boolean;
    /**
     * getAlias 获取别名
     * @param abstract
     */
    getAlias(abstract: string): any;
    /**
     * get 获取实例
     * @param abstract
     */
    get(abstract: string): any;
    /**
     * singleton 单例
     * @param abstract
     * @param concrete
     */
    singleton(abstract: string, concrete: any): void;
    /**
     * getInstance 获取实例
     *
     */
    static getInstance<Instance extends Container>(): Container | Instance;
    /**
     * proxyInstance 代理实例
     *
     */
    protected proxyInstance(): this;
}

/**
 * Service provider
 * @description zh-CN: 服务提供者用于注册服务到容器中，该类为抽象类，所有方法需实现
 */
declare abstract class ServiceProvider {
    protected app: ApplicationInterface;
    /**
     * constructor
     * @param app zh-CN: 应用实例
     * @description zh-CN: 实例化过程中会自动注册该实例到容器中
     */
    constructor(app: ApplicationInterface);
    /**
     * abstract register
     * @description zh-CN: 抽象注册方法需实现
     * @returns void
     */
    abstract register(): void;
}

/**
 * Interface Container
 * @description 容器接口
 */
interface ContainerInterface {
    /**
     * bind 绑定实体
     * @param {String|Array} abstract
     * @param {*} concrete
     */
    bind(abstract: string | string[], concrete: any): void;
    /**
     * make 创建类的实例/获取对象 create instance/object
     * @param abstract
     * @param params
     * @param shared
     */
    make(abstract: string, params?: object | [], shared?: boolean): any;
    /**
     * has as existence
     * 是否存在标识 existence 的别名
     * @param {String} name
     */
    has(name: string): boolean;
    /**
     * existence 存在标识
     * @param {String} name
     */
    existence(name: string): boolean;
    /**
     * getAlias 获取别名
     * @param abstract
     */
    getAlias(abstract: string): string;
    /**
     * get 获取实例
     * @param abstract
     */
    get(abstract: string): any;
    /**
     * singleton 单例
     * @param abstract
     * @param concrete
     */
    singleton(abstract: string, concrete: any): void;
}
/**
 * Interface Application
 * @description 应用接口
 */
interface ApplicationInterface extends ContainerInterface {
    /**
     * getterProviders Providers 获取器
     */
    getterProviders(): any[];
    /**
     * setterProviders Providers
     * 设置器
     * @param providers
     */
    setterProviders<T>(providers: T[]): void;
    /**
     * static getAdapter
     * 适配器 获取器
     * @param adapter
     */
    getterAdapter(adapter: UtilityClass): any;
    /**
     * setAdapter
     * 新增
     * @param adapter
     * @param instance
     * @protected
     */
    setterAdapter(adapter: UtilityClass, instance: UtilityObject): void;
}
declare type HttpRequestMethod = 'post' | 'get' | 'put' | 'delete' | 'POST' | 'GET' | 'PUT' | 'DELETE';
declare type HttpContentType = 'REQUEST_PAYLOAD' | 'JSON' | 'FORM_DATA';
declare type HttpHairstyleMethod = [HttpRequestMethod, HttpContentType];
declare type HttpAutoCarryData = 'REQUEST_HEADERS' | 'REQUEST_DATA';
declare type HttpApi = [string, (HttpRequestMethod | [HttpRequestMethod, HttpContentType])?, (true | false | undefined)?, (true | false | undefined)?];
interface HttpApiMap {
    [api: string]: HttpApi;
}
declare type IHttpSendConfig = {
    host?: string;
    headers?: Record<string, any>;
    mode?: HttpContentType;
    responseData?: boolean;
};
declare type HttpResponseData = {
    code: number;
    msg: string;
    data: any;
    timestamp?: number;
};
interface HttpResponse extends Response {
    data: HttpResponseData;
    [key: string]: any;
}
declare type HelperHttp = <T extends HttpApi | string>(api: T, data?: Record<any, any>, headers?: Record<string, string | number>) => Promise<T[3] extends true ? HttpResponse : HttpResponseData>;
declare type HelperHttpApi = HttpApi | string;
declare type HelperHttpData = Record<any, any>;
declare type HelperHttpHeaders = Record<string, string | number>;
declare type HelperHttpExtra = Record<string, string | number>;
declare type HelperHttpReturn<T extends HelperHttpApi> = T[3] extends true ? HttpResponse : HttpResponseData;
interface HelperInterface {
    env(): Record<any, any>;
    storage(name: string): Record<any, any>;
    storage(name: string, payload?: any): void;
    cookies(name: string): Record<any, any>;
    cookies(name: string, payload?: any): void;
    session(name: string): Record<any, any>;
    session(name: string, payload?: any): void;
    /**
     * 发送一个http请求
     * @param api 接口
     * @param data  请求数据
     * @param headers 自定义头
     * @param extra 额外的参数
     */
    http<T extends HelperHttpApi>(api: T, data?: HelperHttpData, headers?: HelperHttpHeaders, extra?: HelperHttpExtra): Promise<HelperHttpReturn<T>>;
    fetch(api: string | HttpApi, data?: UtilityObject, headers?: Record<string, string | number>): Promise<HttpResponse>;
    send(api: string | HttpApi, data?: UtilityObject, handle?: (response: HttpResponse) => void, config?: IHttpSendConfig, returnResponse?: boolean): Promise<HttpResponse>;
}
/**
 * Adapter Interface
 */
declare type RequestConfig = {
    method?: HttpRequestMethod;
    url?: string;
    data?: Record<string, any>;
    headers?: HeadersInit | Record<string, string | number>;
    header?: HeadersInit | Record<string, string | number>;
    [key: string]: any;
};
declare type IHttpAdapter<T> = (config: RequestConfig) => Promise<T>;
declare type IAxiosAdapterHttp<T> = (config: RequestConfig) => Promise<T>;
/**
 * Service Interface
 */
interface IHttpService {
    send(apiRoute: string, data: Record<string, any>, config?: IHttpSendConfig, returnResponse?: boolean): Promise<any>;
    http<T extends HelperHttpApi>(api: T, data?: HelperHttpData, headers?: HelperHttpHeaders, extra?: HelperHttpExtra): Promise<HelperHttpReturn<T>>;
}
declare type IServiceProvider = typeof ServiceProvider;
declare type APP_CONFIG = {
    PROVIDERS?: IServiceProvider[];
    APP_TYPE: 'VUE' | 'REACT' | 'UNI_APP' | 'MP_VUE' | 'WX_APP';
    HTTP_CONFIG: HTTP_CONFIG;
};
declare type HTTP_CONFIG = {
    HTTP_ADAPTER: any;
    HTTP_LIB: UtilityFunction | UtilityClass;
    HTTP_API: any;
    HTTP_HOST: string;
    IS_RESTFUL: boolean;
    CONTENT_TYPE: HttpContentType;
    DATA_CARRYING: DATA_CARRYING;
    REQUEST_MIDDLEWARE?: HttpMiddleware<any>;
    RESPONSE_MIDDLEWARE?: HttpMiddleware<any>;
};
declare type DATA_CARRYING = {
    REQUEST_DATA?: Record<any, any>;
    REQUEST_HEADERS?: Record<any, any>;
};
declare type HttpMiddleware<T> = (context?: any) => void;
declare type HTTP_SERVICE_CONFIG = Pick<HTTP_CONFIG, 'HTTP_ADAPTER' | 'HTTP_API' | 'HTTP_HOST' | 'IS_RESTFUL' | 'CONTENT_TYPE' | 'DATA_CARRYING' | 'REQUEST_MIDDLEWARE' | 'RESPONSE_MIDDLEWARE'>;
interface IMiddleware<TContext> {
    handle(context: TContext, next: UtilityFunction): void;
}
declare type HttpContext<T> = {
    request: {
        hairstyle: HttpApi;
        body: Record<string, any>;
        data: Record<string, any>;
        auth: boolean;
        headers: Record<string, string | number>;
        method: HttpRequestMethod;
        api: string;
        url: string;
    };
    response: T;
};

/**
 * Application 核心应用
 * @extends Container
 * @author SunnyXu <xy@ztes.com>
 */
declare class Application extends Container {
    private static VERSION;
    private adapters;
    private providers;
    /**
     * lifecycle
     * 生命周期
     * @private
     */
    private static lifecycle;
    /**
     * getterProviders Providers 获取器
     */
    getterProviders(): IServiceProvider[];
    /**
     * getProviders
     * 获取
     * @protected
     */
    private static getProviders;
    /**
     * setterProviders Providers
     * 设置器
     * @param providers
     */
    setterProviders(providers: IServiceProvider[]): void;
    /**
     * setProviders
     * 设置
     * @param providers
     */
    static setProviders(providers: IServiceProvider[]): void;
    /**
     * registerProvider
     * @description 注册服务提供者
     * @param Provider
     */
    static registerProvider(Provider: any): void;
    /**
     * registerProviders
     * 批量注册
     * @param providers
     */
    static registerProviders(providers: IServiceProvider[]): void;
    /**
     * config
     * 配置
     * @param {Object} config
     * @param {String} name
     */
    static setConfig(name: string, config: UtilityObject): void;
    /**
     * getConfig
     * 获取
     * @param name
     * @param {Object} def 默认值
     */
    static getConfig(name: string, def?: any): UtilityObject;
    /**
     * setAppConfig
     * 设置App配置
     * @param config
     */
    static setAppConfig(config: APP_CONFIG): void;
    /**
     * getAppConfig
     * 获取App配置
     * @param name
     * @description 遵守getAppConfig中参数值和返回值的约定
     */
    static getAppConfig<T extends keyof APP_CONFIG>(name: T): APP_CONFIG[T];
    /**
     * bindAdapter
     * @description zh-CN 绑定适配器
     * @param Adapter
     * @param payload
     */
    static bindAdapter(Adapter: UtilityClass, payload?: UtilityObject): void;
    /**
     * setAdapter
     * 新增
     * @param adapter
     * @param instance
     * @protected
     */
    setterAdapter(adapter: UtilityClass, instance: UtilityObject): void;
    /**
     * static getAdapter
     * 获取适配器
     * @param adapter 必须是个类
     * @return instance
     */
    static getAdapter(adapter: UtilityClass): any;
    /**
     * static getAdapter
     * 适配器 获取器
     * @param adapter
     */
    getterAdapter(adapter: UtilityClass): any;
    /**
     * getService
     * 获取服务实例
     * @param serviceName
     */
    static getService<T>(serviceName: string): T;
    /**
     * Application instance
     * 获取应用实例
     * @description 应该使用Proxy进行拦截，目前先放行
     */
    static getInstance(): Application;
    /**
     * App run
     * 框架应用运行
     * @param {CallableFunction} callback
     */
    static run(callback?: CallableFunction): void;
}

/**
 * @description zh-CN 转换器类型
 */
declare type TransformData = Record<string, any> | Record<string, any>[];
declare type TransformFunc = (data: Record<string, any>) => any;
declare type Transform = (data: TransformData, func: TransformFunc) => any;
/**
 * @abstract Class Command
 * @description zh-CN 命令类，私有属性和方法都会携带$标识符
 */
declare abstract class Command {
    protected $payload: any[];
    protected $helper: HelperInterface;
    protected $http: HelperInterface['http'];
    constructor(...payload: any[]);
    abstract handle(...args: any[]): any | Promise<any> | void;
    /**
     * zh-CN 转换器
     * @description zh-CN 简单的转换器，高级转换器请使用Transformer
     * @param data
     * @param func
     */
    protected $transform: Transform;
    /**
     * zh-CN 过滤空字段
     * @param fields
     * @protected
     */
    protected $filterEmptyFields(fields: Record<string, any>): Record<string, any>;
}

declare type Callback = (item: Record<any, any>, index?: number) => Record<any, any>;
/**
 * Class Transformer 转换器
 * NewTransformer extends Transformer -> constructor(){super(data,payload)}
 */
declare class Transformer {
    private readonly data;
    private payload;
    /**
     * Method constructor
     * @param {*} data 需处理的数据
     * @param {*} payload 携带的载荷
     * @returns
     */
    constructor(data: any, payload?: unknown);
    /**
     * Method transform
     * 转换方法
     * @param {Object|String|Number} data
     * @param tData
     * @returns
     */
    transform(data: any, tData?: any): any;
    /**
     * Method create
     * 创建新数据
     * @return {Array/Object|String|Number|*}
     */
    create(callback?: Callback): any;
    /**
     * 格式化数字
     * @param {String|Number} number 待处理数字
     * @param {Number} places 小数点位数 -1为原样保留
     * @param {String} thousand 千位字符串 默认为空
     * @param {String} decimal 小数点替换字符 默认为.
     * @return {String|Number}
     */
    formatNumber(number: string | number, places?: number | string, thousand?: string, decimal?: string): string;
    /**
     * formatDate 日期格式化
     * @param {string|number} timestamp
     * @returns
     */
    formatDate(timestamp?: number | string | unknown): Record<string, number | string>;
}

declare type variableType = 'string' | 'number' | 'object' | 'undefined' | 'function' | 'boolean' | 'bigInt' | 'symbol';
declare type TrimType = 'R' | 'L' | '';
/**
 * Class Lib
 * 基础函数库，Lodash、Underscore... So big
 */
declare class Lib {
    /**
     * typeOf 判断变量类型
     * @param value
     * @param type
     */
    static typeOf<T>(value: unknown, type: variableType): value is T;
    /**
     * getTag 判断变量类型
     * @param value
     */
    static getTag(value: unknown): string;
    /**
     * isFunction 是否函数
     * @param {Function} value
     * @return {Boolean}
     */
    static isFunction(value: unknown): value is typeof Function;
    /**
     * isString 是否字符串
     * @param {String} value
     * @return {Boolean}
     */
    static isString(value: unknown): value is string;
    /**
     * isNumber 是否数字
     * @param value
     * @return {Boolean}
     */
    static isNumber(value: unknown): value is number;
    /**
     * isObject 是否对象
     * @param {Object} value
     */
    static isObject(value: unknown): value is Record<any, any>;
    /**
     * isObject 是否Undefined
     * @param {*} value
     * @return boolean
     */
    static isUndefined(value: unknown): boolean;
    /**
     * isNull 是否Null
     * @param value
     */
    static isNull(value: unknown): boolean;
    /**
     * isEmpty 是否空
     * 目前只对 null undefined '' {} [] 做处理
     * @param value
     */
    static isEmpty(value: unknown): boolean;
    /**
     * isClass 是否类
     * @param value
     */
    static isClass(value: unknown): boolean;
    /**
     * 字符串去除首尾字符
     * @param str 字符串
     * @param char 字符
     * @param type 类型
     */
    static strTrim(str: string, char: string, type?: TrimType): string;
}

declare abstract class HttpAdapterInterface<T> {
    protected http: IHttpAdapter<T>;
    protected method: HttpRequestMethod;
    protected url: string;
    protected data: {};
    protected headers: {};
    protected extra: {};
    /**
     * Method constructor 注入Axios
     * @param {*} $function
     * @returns
     */
    protected constructor($function: IHttpAdapter<T>);
    /**
     * Method setConfig
     * 设置配置信息
     * @param {method,url,data,headers} param
     */
    setConfig({ method, url, data, headers, extra }: RequestConfig): void;
    /**
     * Method request
     * @returns Promise
     */
    request(): Promise<unknown>;
}

/**
 * Class AxiosAdapter
 * @description axios适配器，适配器主要完成
 */
declare class AxiosAdapter extends HttpAdapterInterface<{}> {
    /**
     * Method request
     * @returns Promise
     */
    request(): Promise<unknown>;
}

/**
 * Class UniRequestAdapter
 * @description uni.request请求适配器，适配器主要完成
 */
declare class UniRequestAdapter extends HttpAdapterInterface<{}> {
    /**
     * Method request
     * @returns Promise
     */
    request(): Promise<unknown>;
}

declare function $http<T extends HelperHttpApi>(api: T, data: HelperHttpData, headers?: HelperHttpHeaders, extra?: HelperHttpExtra): Promise<HelperHttpReturn<T>>;

declare function isArray(obj: any): obj is any[];
declare function isNull(obj: any): obj is null;
declare function isBoolean(obj: unknown): obj is boolean;
declare function isObject(obj: any): obj is Record<string, unknown>;
declare const isPromise: <T>(obj: unknown) => obj is Promise<T>;
declare function isString(obj: any): obj is string;
declare function isNumber(obj: any): obj is number;
declare function isRegExp(obj: any): boolean;
declare function isDate(obj: any): boolean;
declare function isColor(color: any): boolean;
declare function isUndefined(obj: any): obj is undefined;
declare function isFunction(obj: any): obj is (...args: any[]) => any;
declare function isClass(value: unknown): boolean;
declare function isEmptyObject(obj: any): boolean;
declare function isEmpty(obj: any): boolean;
declare function isExist(obj: any): boolean;
declare function isWindow(el: any): el is Window;
declare function isPhone(phone: unknown): boolean;
declare function isEmail(email: unknown): boolean;

declare class EventBus {
    _events: Map<any, any>;
    static _instance: InstanceType<typeof EventBus>;
    /**
     * 获取EventBus实例
     * @return {EventBus}
     */
    static getInstance(): EventBus;
    /**
     * EventBus.getEvents
     * @return {Map<any, any>}
     */
    static getEvents(): Map<any, any>;
    static getEventsSize(): number;
    static getEvent(name: string): any;
    static hasEvent(name: string): boolean;
    static deleteEvent(name: string): boolean;
    /**
     * Method EventBus.setEvent
     * @param name
     * @param callback
     * @return {Map<any, any>}
     */
    static setEvent(name: string, callback: CallableFunction): Map<any, any>;
    /**
     * Method EventBus.on as EventBus.setEvent
     * 绑定事件
     * @param name
     * @param callback
     * @return {Map<*, *>}
     */
    static on(name: string, callback: CallableFunction): Map<any, any>;
    /**
     * Method EventBus.emit
     * 执行事件
     * @param name
     * @param payload
     * @return {*}
     */
    static emit(name: string, ...payload: any[]): any;
    /**
     * Method EventBus.once
     * 执行事件并关闭事件
     * @param name
     * @param payload
     */
    static once(name: string, ...payload: any[]): void;
    /**
     * EventBus.off
     * 关闭事件
     * @param name
     * @return {boolean}
     */
    static off(name: string): boolean;
}

/**
 * Exception Class
 * 目前原生的错误类型
 * Error [一般错误类型]
 * SyntaxError [语法错误]
 * ReferenceError [不存在的变量]
 * RangeError [超出有效范围]
 * TypeError [非预期类型]
 * URIError [URI参数错误]
 * EvalError [eval函数没有正确执行]
 * Example: throw new Exception() catch(error) error.name,error.message,error.code,error.stack
 */
declare class Exception extends Error {
    name: string;
    message: string;
    code: number;
    /**
     *
     * @param {String} name 错误名称
     * @param {String} message 错误提示
     * @param {Number} code 错误码
     */
    constructor(name: string, message: string, code?: number);
}

/**
 * 将对象转换为查询字符串
 * @param jsonData
 * @param jsonDataKey
 * @returns
 */
declare function queryStringify(jsonData: Record<string, any>, jsonDataKey?: string): string;

declare function defineAppConfig(config: APP_CONFIG): APP_CONFIG;
declare function defineHttpConfig<T>(config: HTTP_CONFIG | T): HTTP_CONFIG | T;
declare function defineHttpApis(apis: HttpApiMap): HttpApiMap;
declare function defineHttpApiMap(apiMap: HttpApiMap): HttpApiMap;

export { $http, APP_CONFIG, ApplicationInterface, AxiosAdapter, Command, Container, ContainerInterface, DATA_CARRYING, EventBus, Exception, HTTP_CONFIG, HTTP_SERVICE_CONFIG, HelperHttp, HelperHttpApi, HelperHttpData, HelperHttpExtra, HelperHttpHeaders, HelperHttpReturn, HelperInterface, HttpApi, HttpApiMap, HttpAutoCarryData, HttpContentType, HttpContext, HttpHairstyleMethod, HttpMiddleware, HttpRequestMethod, HttpResponse, HttpResponseData, IAxiosAdapterHttp, IHttpAdapter, IHttpSendConfig, IHttpService, IMiddleware, IServiceProvider, Lib, RequestConfig, ServiceProvider, Transformer, UniRequestAdapter, Application as default, defineAppConfig, defineHttpApiMap, defineHttpApis, defineHttpConfig, isArray, isBoolean, isClass, isColor, isDate, isEmail, isEmpty, isEmptyObject, isExist, isFunction, isNull, isNumber, isObject, isPhone, isPromise, isRegExp, isString, isUndefined, isWindow, queryStringify };