log4js

configure: (
    config?: Config,
    layouts?: LayoutsParam,
    findAppender?: () => AppenderFunction,
    levels?: Levels
) => AppenderFunction;

CategoryFilterAppender: CategoryFilterAppender;

ConsoleAppender: ConsoleAppender;

CustomAppender: CustomAppender;

DateFileAppender: DateFileAppender;

FileAppender: FileAppender;

LogLevelFilterAppender: LogLevelFilterAppender;

MultiFileAppender: MultiFileAppender;

MultiprocessAppender: MultiprocessAppender;

NoLogFilterAppender: NoLogFilterAppender;

RecordingAppender: RecordingAppender;

StandardErrorAppender: StandardErrorAppender;

StandardOutputAppender: StandardOutputAppender;

SyncfileAppender: SyncfileAppender;

TCPAppender: TCPAppender;

type: 'basic';

callStack: string;

columnNumber: number;

fileName: string;

functionName: string;

lineNumber: number;

appender?: string;

exclude?: string | string[];

type: 'categoryFilter';

type: 'colored' | 'coloured';

appenders: { [name: string]: Appender };

categories: {
    [name: string]: {
        appenders: string[];
        level: string;
        enableCallStack?: boolean;
    };
};

disableClustering?: boolean;

levels?:
    | Levels
    | {
          [name: string]: {
              value: number;
              colour: string;
          };
      };

pm2?: boolean;

pm2InstanceVar?: string;

layout?: Layout;

type: 'console';

type: string | AppenderModule;

[key: string]: any;

type: string;

[key: string]: any;

alwaysIncludePattern?: boolean;

compress?: boolean;

encoding?: string;

filename: string;

fileNameSep?: string;

flags?: string;

keepFileExt?: boolean;

layout?: Layout;

mode?: number;

numBackups?: number;

pattern?: string;

type: 'dateFile';

type: 'dummy';

backups?: number;

compress?: boolean;

encoding?: string;

filename: string;

fileNameSep?: string;

flags?: string;

keepFileExt?: boolean;

layout?: Layout;

maxLogSize?: number | string;

mode?: number;

type: 'file';

addLayout: (name: string, serializerGenerator: LayoutFunction) => void;

basicLayout: LayoutFunction;

coloredLayout: LayoutFunction;

colouredLayout: LayoutFunction;

dummyLayout: LayoutFunction;

layout: (name: string, config: PatternToken) => LayoutFunction;

messagePassThroughLayout: LayoutFunction;

patternLayout: LayoutFunction;

colour: string;

level: number;

levelStr: string;

isEqualTo: { (other: string): boolean; (otherLevel: Level): boolean };

isGreaterThanOrEqualTo: {
    (other: string): boolean;
    (otherLevel: Level): boolean;
};

isLessThanOrEqualTo: { (other: string): boolean; (otherLevel: Level): boolean };

ALL: Level;

DEBUG: Level;

ERROR: Level;

FATAL: Level;

INFO: Level;

levels: Level[];

MARK: Level;

OFF: Level;

TRACE: Level;

WARN: Level;

addLevels: (customLevels: object) => void;

getLevel: (level: Level | string, defaultLevel?: Level) => Level;

levels: Levels;

addLayout: (
    name: string,
    config: (a: any) => (logEvent: LoggingEvent) => string
) => void;

configure: { (filename: string): Log4js; (config: Configuration): Log4js };

connectLogger: (
    logger: Logger,
    options: { format?: Format; level?: string; nolog?: any }
) => any;

getLogger: (category?: string) => Logger;

isConfigured: () => boolean;

shutdown: (cb?: (error?: Error) => void) => void;

callStackLinesToSkip: number;

readonly category: string;

level: Level | string;

addContext: (key: string, value: any) => void;

clearContext: () => void;

debug: (message: any, ...args: any[]) => void;

error: (message: any, ...args: any[]) => void;

fatal: (message: any, ...args: any[]) => void;

info: (message: any, ...args: any[]) => void;

isDebugEnabled: () => boolean;

isErrorEnabled: () => boolean;

isFatalEnabled: () => boolean;

isInfoEnabled: () => boolean;

isLevelEnabled: (level?: string) => boolean;

isTraceEnabled: () => boolean;

isWarnEnabled: () => boolean;

log: (level: Level | string, ...args: any[]) => void;

mark: (message: any, ...args: any[]) => void;

removeContext: (key: string) => void;

setParseCallStackFunction: (
    parseFunction: (error: Error, linesToSkip: number) => CallStack | undefined
) => void;

trace: (message: any, ...args: any[]) => void;

warn: (message: any, ...args: any[]) => void;

new (name: string): Logger;

categoryName: string;

cluster?: {
    workerId: number;
    worker: number;
};

context: any;

data: any[];

error?: Error;

level: Level;

pid: number;

startTime: Date;

serialise: () => string;

appender: string;

level: string;

maxLevel?: string;

type: 'logLevelFilter';

type: 'messagePassThrough';

base: string;

extension: string;

property: string;

type: 'multiFile';

appender?: string;

loggerHost?: string;

loggerPort?: number;

mode: 'master' | 'worker';

type: 'multiprocess';

appender: string;

exclude: string | string[];

type: 'noLogFilter';

pattern: string;

tokens?: { [name: string]: Token };

type: 'pattern';

pattern: string;

tokens: { [tokenName: string]: () => any };

configure: () => AppenderFunction;

erase: () => void;

playback: () => LoggingEvent[];

replay: () => LoggingEvent[];

reset: () => void;

type: 'recording';

layout?: Layout;

type: 'stderr';

layout?: Layout;

type: 'stdout';

backups?: number;

encoding?: string;

filename: string;

flags?: string;

layout?: Layout;

maxLogSize?: number | string;

mode?: number;

type: 'fileSync';

endMsg?: string;

host?: string;

layout?: Layout;

port?: number;

type: 'tcp';