import { LoggerFactory } from "./LoggerFactory";
import { ContextLogger, LoggerProxy } from "./LoggerProxy";
import { Logger } from "./Logger";
export type ClassCategory = (clazz: Function) => string;
export declare const defaultClassCategory: ClassCategory;
export type ConstructorCategory = (clazz: Function, argArray: any[]) => string;
export declare const defaultConstructorCategory: ConstructorCategory;
export type InstanceCategory = (clazz: Function, instance: any) => string;
export declare const defaultInstanceCategory: InstanceCategory;
export type FunctionCategory = (func: Function, clazzOrInstanceCategory?: string, clazzOrInstancePropName?: string) => string;
export declare const defaultFunctionCategory: FunctionCategory;
export type FunctionArgumentNames = (func: Function) => string[];
export declare const defaultFunctionArgumentNames: FunctionArgumentNames;
export type ArgumentCategory = (index: number, name?: string) => string;
export declare const defaultArgumentCategory: ArgumentCategory;
export type Continuer = (category: string, object: any) => boolean;
export declare const defaultContinuer: Continuer;
export declare const validContinuer: Continuer;
export declare class DefaultLoggerProxy implements LoggerProxy {
    private readonly logger;
    private functionHierarchy;
    loggerFactory: LoggerFactory;
    spacing: string;
    startMark: string;
    endMark: string;
    verbose: boolean;
    classCategory: ClassCategory;
    constructorCategory: ConstructorCategory;
    instanceCategory: InstanceCategory;
    functionCategory: FunctionCategory;
    functionArgumentNames: FunctionArgumentNames;
    argumentCategory: ArgumentCategory;
    argumentContinuer: Continuer;
    returnContinuer: Continuer;
    constructor(loggerFactory: LoggerFactory);
    private static _logger?;
    static getLogger(defaultLogger?: Logger): Logger | undefined;
    proxyClass<T extends Function>(clazz: T): T;
    private _continuer;
    private doProxyConstruct;
    proxyInstance<T extends object>(instance: T, category?: string): T;
    bridgeUnproxifiableProperty: boolean;
    private doProxyInstance;
    /**
     * @see <a href="https://stackoverflow.com/questions/36372611/how-to-test-if-an-instance-is-a-proxy">如何判断对象是否 Proxy</a>
     */
    private filterFunction;
    proxyFunction<T extends Function>(func: T, category?: string): T;
    private static _funcsCache;
    private doProxyFunctionCachely;
    private doProxyFunction;
    protected doProxy<T extends Function>(category: string, target: T, argArray: any[], invoker: () => any): any;
    protected doProxyContinuer(object: any, category: string): any;
    private static isPlainObject;
}
export declare const contextLogger: ContextLogger;