log4javascript.d.ts

// Type definitions for log4javascript v1.4.10
// Project: http://log4javascript.org/
// Definitions by: Markus Wagner <https://github.com/Ritzlgrmft/>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

declare namespace log4javascript {

	// #region log4javascript static properties/methods

	/**
	 * Returns a logger with the specified name, creating it if a logger with that name does not already exist.
	 * If no name is specified, a logger is returned with name [anonymous], and subsequent calls to getLogger()
	 * (with no logger name specified) will return this same logger object.
	 * Note that the names [anonymous], [default], [null] and root are reserved for the anonymous logger, default logger,
	 * null logger and root logger respectively.
	 */
	export function getLogger(loggerName?: string): Logger;

	/**
	 * Convenience method that returns the default logger. The default logger has a single appender: a PopUpAppender with the default
	 * layout, width and height, and with focusPopUp set to false and lazyInit, useOldPopUp and complainAboutPopUpBlocking all set to true.
	 */
	export function getDefaultLogger(): Logger;

	/**
	 * Returns an empty logger with no appenders. Useful for disabling all logging.
	 */
	export function getNullLogger(): Logger;

	/**
	 * Returns the root logger from which all other loggers derive.
	 */
	export function getRootLogger(): Logger;

	/**
	 * Resets the all loggers to their default level.
	 */
	export function resetConfiguration(): void;

	/**
	 * Enables or disables all logging, depending on enabled.
	 */
	export function setEnabled(enabled: boolean): void;

	/**
	 * Returns true or false depending on whether logging is enabled.
	 */
	export function isEnabled(): boolean;

	/**
	 * Adds a function to be called when an event of the type specified occurs in log4javascript.
	 * Supported event types are load (occurs once the page has loaded) and error.
	 */
	export function addEventListener(eventType: string, listener: { (sender: any, eventType: string, eventArgs: any): void; }): void;

	/**
	 * Removes the event listener function supplied for the event of the type specified.
	 */
	export function removeEventListener(eventType: string, listener: { (sender: any, eventType: string, eventArgs: any): void; }): void;

	/**
	 * Raises an event of type eventType on the log4javascript object. Each of the listeners for this type of event
	 * (registered via addEventListener) is called and passed eventArgs as the third parameter.
	 */
	export function dispatchEvent(eventType: string, eventArgs: any): void;

	/**
	 * Used internally to specify the types of events that the log4javascript object can raise.
	 */
	export function setEventTypes(eventTypes: string[]): void;

	/**
	 * Enables or disables displaying of error stack traces, depending on show. By default, stack traces are not displayed.
	 * (Only works in Firefox)
	 */
	export function setShowStackTraces(show: boolean): void;

	/**
	 * This evaluates the given expression in the log4javascript scope, thus allowing scripts to access internal
	 * log4javascript variables and functions. This was written for the purposes of automated testing but could be used by
	 * custom extensions to log4javascript.
	 */
	export function evalInScope(expr: string): any;

	// #endregion

	// #region Levels

	/**
	 * Levels are available as static properties of the log4javascript.Level object.
	 */
	export enum Level { ALL, TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF }

	// #endregion

	// #region Loggers

	/**
	 * It is possible to have multiple loggers in log4javascript. For example, you may wish to have a logger for debugging purposes
	 * that logs messages to a pop-up window and a separate logger that reports any client-side application errors to the server via Ajax.
	 * From version 1.4, log4javascript has hierarchical loggers, implemented in the same way as log4j. In summary, you specify a
	 * logger's parent logger by means of a dot between the parent logger name and the child logger name. Therefore the logger
	 * tim.app.security inherits from tim.app, which in turn inherits from tim which, finally, inherits from the root logger.
	 * What inheritance means for a logger is that in the absence of a threshold level set specifically on the logger it inherits
	 * its level from its parent; also, a logger inherits all its parent's appenders (this is known as appender additivity in log4j.
	 * This behaviour can be enabled or disabled via setAdditivity(). See below). In the above example, if the root logger has a
	 * level of DEBUG and one appender, each of the loggers tim.app.security, tim.app and tim would inherit the root level's appender.
	 * If, say, tim.app's threshold level was set to WARN, tim's effective level would remain at DEBUG (inherited from the root logger)
	 * while tim.app.security's effective level would be WARN, inherited from tim.app. The important thing to note is that appenders
	 * accumulate down the logger hierarchy while levels are simply inherited from the nearest ancestor with a threshold level set.
	 * For a detailed explanation of the logger hierarchy, see the log4j manual.
	 */
	export class Logger {
		/**
		 * Adds the given appender.
		 */
		addAppender(appender: Appender): void;

		/**
		 * Removes the given appender.
		 */
		removeAppender(appender: Appender): void;

		/**
		 * Clears all appenders for the current logger.
		 */
		removeAllAppenders(): void;

		/**
		 * Sets the level. Log messages of a lower level than level will not be logged. Default value is DEBUG.
		 */
		setLevel(level: Level): void;

		/**
		 * Returns the level explicitly set for this logger or null if none has been set.
		 */
		getLevel(): Level;

		/**
		 * Returns the level at which the logger is operating. This is either the level explicitly set on the logger or, if no level
		 * has been set, the effective level of the logger's parent.
		 */
		getEffectiveLevel(): Level;

		/**
		 * Sets whether appender additivity is enabled (the default) or disabled. If set to false, this particular logger will not
		 * inherit any appenders form its ancestors. Any descendant of this logger, however, will inherit from its ancestors as
		 * normal, unless its own additivity is explicitly set to false.
		 * Default value is true.
		 */
		setAdditivity(additivity: boolean): void;

		/**
		 * Returns whether additivity is enabled for this logger.
		 */
		getAdditivity(): boolean;

		/**
		 * Generic logging method used by wrapper methods such as debug, error etc.
		 */
		log(level: Level, params: any[]): void;

		/**
		 * Logs one or more messages and optionally an error at level TRACE.
		 */
		trace(...messages: any[]): void;

		/**
		 * Logs one or more messages and optionally an error at level DEBUG.
		 */
		debug(...messages: any[]): void;

		/**
		 * Logs one or more messages and optionally an error at level INFO.
		 */
		info(...messages: any[]): void;

		/**
		 * Logs one or more messages and optionally an error at level WARN.
		 */
		warn(...messages: any[]): void;

		/**
		 * Logs one or more messages and optionally an error at level ERROR.
		 */
		error(...messages: any[]): void;

		/**
		 * Logs one or more messages and optionally an error at level FATAL.
		 */
		fatal(...messages: any[]): void;

		/**
		 * Returns whether the logger is enabled for the specified level.
		 */
		isEnabledFor(level: Level, exception: Error): boolean;

		/**
		 * Returns whether the logger is enabled for TRACE messages.
		 */
		isTraceEnabled(): boolean;

		/**
		 * Returns whether the logger is enabled for DEBUG messages.
		 */
		isDebugEnabled(): boolean;

		/**
		 * Returns whether the logger is enabled for INFO messages.
		 */
		isInfoEnabled(): boolean;

		/**
		 * Returns whether the logger is enabled for WARN messages.
		 */
		isWarnEnabled(): boolean;

		/**
		 * Returns whether the logger is enabled for ERROR messages.
		 */
		isErrorEnabled(): boolean;

		/**
		 * Returns whether the logger is enabled for FATAL messages.
		 */
		isFatalEnabled(): boolean;

		/**
		 * Starts a new group of log messages. In appenders that support grouping (currently PopUpAppender and InPageAppender),
		 * a group appears as an expandable section in the console, labelled with the name specified. Specifying initiallyExpanded
		 * determines whether the group starts off expanded (the default is true). Groups may be nested.
		 */
		group(name: string, initiallyExpanded?: boolean): void;

		/**
		 * Ends the current group. If there is no group then this function has no effect.
		 */
		groupEnd(): void;

		/**
		 * Starts a timer with name name. When the timer is ended with a call to timeEnd using the same name, the amount of time
		 * that has elapsed in milliseconds since the timer was started is logged at level level. If not level is supplied, the level
		 * defaults to INFO.
		 */
		time(name: string, level?: Level): void;

		/**
		 * Ends the timer with name name and logs the time elapsed.
		 */
		timeEnd(name: string): void;

		/**
		 * Asserts the given expression is true or evaluates to true. If so, nothing is logged. If not, an error is logged at the ERROR level.
		 */
		assert(expr: any): void;

		name: string;
	}

	// #endregion

	// #region Appenders

	/**
	 * Logging event.
	 */
	export class LoggingEvent {
		logger: Logger;
		timeStamp: Date;
		timeStampInMilliseconds: number;
		timeStampInSeconds: number;
		milliseconds: number;
		level: Level;
		messages: any[];
		exception: Error;

		getThrowableStrRep: () => string;
		getCombinedMessages: () => string;
		toString: () => string;
	}

	/**
	 * There are methods common to all appenders, as listed below.
	 */
	export class Appender {

		/**
		 * Checks the logging event's level is at least as severe as the appender's threshold and calls the appender's append method if so.
		 * This method should not in general be used directly or overridden.
		 */
		doAppend(loggingEvent: LoggingEvent): void;

		/**
		 * Appender-specific method to append a log message. Every appender object should implement this method.
		 */
		append(loggingEvent: LoggingEvent): void;

		/**
		 * Sets the appender's layout.
		 */
		setLayout(layout: Layout): void;

		/**
		 * Returns the appender's layout.
		 */
		getLayout(): Layout;

		/**
		 * Sets the appender's threshold. Log messages of level less severe than this threshold will not be logged.
		 */
		setThreshold(level: Level): void;

		/**
		 * Returns the appender's threshold.
		 */
		getThreshold(): Level;

		/**
		 * Returns a string representation of the appender. Every appender object should implement this method.
		 */
		toString(): string;

	}

	/**
	 * Displays a log message as a JavaScript alert.
	 */
	export class AlertAppender extends Appender {
		/**
		 * Constructor
		 */
		constructor();
	}

	/**
	 * A flexible appender that asynchronously sends log messages to a server via HTTP.
	 * The default configuration is to send each log message as a separate HTTP post request to the server using an
	 * HttpPostDataLayout, without waiting for a response before sending any subsequent requests.
	 */
	export class AjaxAppender extends Appender {
		/**
		 * Constructor
		 * @param url The URL to which log messages should be sent. Note that this is subject to the usual Ajax restrictions:
		 * the URL should be in the same domain as that of the page making the request.
		 * @param withCredentials Specifies whether cookies should be sent with each request.
		 */
		constructor(url: string, withCredentials?: boolean);

		/**
		 * Whether to send all remaining unsent log messages to the server when the page unloads.
		 * Since version 1.4.3, the default value is false. Previously the default was true.
		 */
		setSendAllOnUnload(sendAllOnUnload: boolean): void;

		/**
		 * Returns whether all remaining unsent log messages are sent to the server when the page unloads.
		 */
		isSendAllOnUnload(): boolean;

		/**
		 * Sets the post variable name whose value will the formatted log message(s) for each request.
		 * Default value is data.
		 */
		setPostVarName(postVarName: string): void;

		/**
		 * Returns the post variable name whose value will the formatted log message(s) for each request.
		 */
		getPostVarName(): string;

		/**
		 * Whether to send log messages to the server at regular, timed intervals.
		 * Default value is false.
		 */
		setTimed(timed: boolean): void;

		/**
		 * Returns whether log messages are sent to the server at regular, timed intervals.
		 */
		isTimed(): boolean;

		/**
		 * Sets whether to wait for a response from a previous HTTP request from this appender before sending the next log
		 * message / batch of messages.
		 * Default value is false.
		 */
		setWaitForResponse(waitForResponse: boolean): void;

		/**
		 * Returns whether the appender waits for a response from a previous HTTP request from this appender before sending the next
		 * log message / batch of messages.
		 */
		isWaitForResponse(): boolean;

		/**
		 * Sets the number of log messages to send in each request. If not specified, defaults to 1.
		 */
		setBatchSize(batchSize: number): void;

		/**
		 * Returns the number of log messages sent in each request. See above for more details.
		 */
		getBatchSize(): number;

		/**
		 * Sets the length of time in milliseconds between each sending of queued log messages.
		 */
		setTimerInterval(timerInterval: number): void;

		/**
		 * Returns the length of time in milliseconds between each sending of queued log messages. See above for more details.
		 */
		getTimerInterval(): number;

		/**
		 * Sets the function that is called whenever a successful request is made, called at the point at which the response is
		 * received. This feature can be used to confirm whether a request has been successful and act accordingly.
		 * A single parameter, xmlHttp, is passed to the callback function. This is the XMLHttpRequest object that performed the
		 * request.
		 */
		setRequestSuccessCallback(requestSuccessCallback: { (xmlHttp: XMLHttpRequest): void; }): void;

		/**
		 * Sets the function that is called whenever any kind of failure occurs in the appender, including browser deficiencies or
		 * configuration errors (e.g. supplying a non-existent URL to the appender). This feature can be used to handle
		 * AjaxAppender-specific errors.
		 * A single parameter, message, is passed to the callback function. This is the error-specific message that caused the failure.
		 */
		setFailCallback(failCallback: { (message: string): void; }): void;

		/**
		 * Sets the session id sent to the server each time a request is made.
		 */
		setSessionId(sessionId: string): void;

		/**
		 * Returns the session id sent to the server each time a request is made.
		 */
		getSessionId(): string;

		/**
		 * Adds an HTTP header that is sent with each request.
		 */
		addHeader(name: string, value: string): void;

		/**
		 * Returns an array of the additional headers that are sent with each HTTP request. Each array item is an object with
		 * properties name and value.
		 */
		getHeaders(): Array<{ name: string; value: string; }>;

		/**
		 * Sends all log messages in the queue. If log messages are batched then only completed batches are sent.
		 */
		sendAll(): void;
	}

	/**
	 * Logs messages to a pop-up console window (note: you will need to disable pop-up blockers to use it). The pop-up displays a
	 * list of all log messages.
	 */
	export class PopUpAppender extends Appender {
		/**
		 * Constructor
		 * @param lazyInit Set this to true to open the pop-up only when the first log message reaches the appender. Otherwise, the
		 * pop-up window opens as soon as the appender is created. If not specified, defaults to false.
		 * @param initiallyMinimized Whether the console window should start off hidden / minimized. If not specified, defaults to false.
		 * @param useDocumentWrite Specifies how the console window is created. By default, the console window is created dynamically
		 * using document's write method. This has the advantage of keeping all the code in one single JavaScript file. However,
		 * if your page sets document.domain then the browser prevents script access to a window unless it too has the same value
		 * set for document.domain. To get round this issue, you can set useDocumentWrite to false and log4javascript will instead
		 * use the external HTML file console.html (or console_uncompressed.html if you're using an uncompressed version of
		 * log4javascript.js), which must be placed in the same directory as your log4javascript.js file.
		 * Note that if useDocumentWrite is set to true, the old pop-up window will always be closed and a new one created whenever
		 * the page is refreshed, even if setUseOldPopUp(true) has been called.
		 * In general it's simpler to use the document.write method, so unless your page needs to set document.domain,
		 * useDocumentWrite should be set to true.
		 * If not specified, defaults to true.
		 * @param width The outer width in pixels of the pop-up window. If not specified, defaults to 600.
		 * @param height The outer height in pixels of the pop-up window. If not specified, defaults to 400.
		 */
		constructor(lazyInit?: boolean, initiallyMinimized?: boolean, useDocumentWrite?: boolean, width?: number, height?: number);

		/**
		 * Returns whether the console window starts off hidden / minimized.
		 */
		isInitiallyMinimized(): boolean;

		/**
		 * Sets whether the console window should start off hidden / minimized.
		 */
		setInitiallyMinimized(initiallyMinimized: boolean): void;

		/**
		 * Returns whether the pop-up window is focussed (i.e. brought it to the front) when a new log message is added. Default value is false.
		 */
		isFocusPopUp(): boolean;

		/**
		 * Sets whether to focus the pop-up window (i.e. bring it to the front) when a new log message is added.
		 */
		setFocusPopUp(focusPopUp: boolean): void;

		/**
		 * Returns whether the same pop-up window is used if the main page is reloaded. If set to true, when the page is reloaded a
		 * line is drawn in the pop-up and subsequent log messages are added to the same pop-up. Otherwise, a new pop-up window is
		 * created that replaces the original pop-up. If not specified, defaults to true.
		 */
		isUseOldPopUp(): boolean;

		/**
		 * Sets whether to use the same pop-up window if the main page is reloaded. See isUseOldPopUp above for details.
		 */
		setUseOldPopUp(useOldPopUp: boolean): void;

		/**
		 * Returns whether an alert is shown to the user when the pop-up window cannot be created as a result of a pop-up blocker.
		 * Default value is true.
		 */
		isComplainAboutPopUpBlocking(): boolean;

		/**
		 * Sets whether to announce to show an alert to the user when the pop-up window cannot be created as a result of a pop-up blocker.
		 */
		setComplainAboutPopUpBlocking(complainAboutPopUpBlocking: boolean): void;

		/**
		 * Returns whether new log messages are displayed at the top of the pop-up window. Default value is false (i.e. log messages
		 * are appended to the bottom of the window).
		 */
		isNewestMessageAtTop(): boolean;

		/**
		 * Sets whether to display new log messages at the top inside the pop-up window.
		 */
		setNewestMessageAtTop(newestMessageAtTop: boolean): void;

		/**
		 * Returns whether the pop-up window scrolls to display the latest log message when a new message is logged. Default value is true.
		 */
		isScrollToLatestMessage(): boolean;

		/**
		 * Sets whether to scroll the pop-up window to display the latest log message when a new message is logged.
		 */
		setScrollToLatestMessage(scrollToLatestMessage: boolean): void;

		/**
		 * Returns whether the pop-up window reopens automatically after being closed when a new log message is logged. Default value is false.
		 */
		isReopenWhenClosed(): boolean;

		/**
		 * Sets whether to reopen the pop-up window automatically after being closed when a new log message is logged.
		 */
		setReopenWhenClosed(reopenWhenClosed: boolean): void;

		/**
		 * Returns the outer width in pixels of the pop-up window.
		 */
		getWidth(): number;

		/**
		 * Sets the outer width in pixels of the pop-up window.
		 */
		setWidth(width: number): void;

		/**
		 * Returns the outer height in pixels of the pop-up window.
		 */
		getHeight(): number;

		/**
		 * Sets the outer height in pixels of the pop-up window.
		 */
		setHeight(height: number): void;

		/**
		 * Returns the largest number of log messages that are displayed and stored by the the console. Once reached, a new log
		 * message wil cause the oldest message to be discarded. Default value is null, which means no limit is applied.
		 */
		getMaxMessages(): number;

		/**
		 * Sets the largest number of messages displayed and stored by the console window. Set this to null to make this number unlimited.
		 */
		setMaxMessages(maxMessages: number): void;

		/**
		 * Returns whether the console includes a command line. Default value is true.
		 */
		isShowCommandLine(): boolean;

		/**
		 * Sets whether the console includes a command line.
		 */
		setShowCommandLine(showCommandLine: boolean): void;

		/**
		 * Returns the number of levels to expand when an object value is logged to the console. Each property of an object above
		 * this threshold will be expanded if it is itself an object or array, otherwise its string representation will be displayed.
		 * Default value is 1 (i.e. the properties of the object logged will be displayed in their string representation but not expanded).
		 */
		getCommandLineObjectExpansionDepth(): number;

		/**
		 * Sets the number of levels to expand when an object value is logged to the console.
		 */
		setCommandLineObjectExpansionDepth(expansionDepth: number): void;

		/**
		 * Returns a reference to the window in which commands typed into the command line are currently being executed.
		 */
		getCommandWindow(): Window;

		/**
		 * Sets the window in which commands typed into the command line are executed.
		 */
		setCommandWindow(commandWindow: Window): void;

		/**
		 * Returns the layout used to format the output for commands typed into the command line. The default value is a
		 * PatternLayout with pattern string %m
		 */
		getCommandLayout(): Layout;

		/**
		 * Sets the layout used to format the output for commands typed into the command line.
		 */
		setCommandLayout(commandLayout: Layout): void;

		/**
		 * Clears all messages from the console window.
		 */
		clear(): void;

		/**
		 * Closes the pop-up window.
		 */
		close(): void;

		/**
		 * Opens the pop-up window, if not already open.
		 */
		show(): void;

		/**
		 * Closes the pop-up window.
		 */
		hide(): void;

		/**
		 * Brings the console window to the top and gives it the focus.
		 */
		focus(): void;

		/**
		 * Brings the console window to the top and gives the focus to the command line.
		 */
		focusCommandLine(): void;

		/**
		 * Brings the console window to the top and gives the focus to the search box.
		 */
		focusSearch(): void;

		/**
		 * Evaluates the expression and appends the result to the console.
		 */
		evalCommandAndAppend(expr: string): void;

		/**
		 * Adds a function with the name specified to the list of functions available on the command line. This feature may be used
		 * to add custom functions to the command line.
		 */
		addCommandLineFunction(functionName: string,
			commandLineFunction: { (appender: Appender, args: any, returnValue: { appendResult: boolean; isError: boolean; }): any; }): void;
	}

	/**
	 * Logs messages to a console window in the page. The console is identical to that used by the PopUpAppender, except for the
	 * absence of a 'Close' button.
	 */
	export class InPageAppender extends Appender {
		/**
		 * Constructor
		 * @param container The container element for the console window. This should be an HTML element.
		 * @param lazyInit Set this to true to create the console only when the first log message reaches the appender. Otherwise,
		 * the console is initialized as soon as the appender is created. If not specified, defaults to true.
		 * @param initiallyMinimized Whether the console window should start off hidden / minimized. If not specified, defaults to false
		 * @param useDocumentWrite Specifies how the console window is created. By default, the console window is created dynamically
		 * using document's write method. This has the advantage of keeping all the code in one single JavaScript file. However,
		 * if your page sets document.domain then the browser prevents script access to a window unless it too has the same value
		 * set for document.domain. To get round this issue, you can set useDocumentWrite to false and log4javascript will instead
		 * use the external HTML file console.html (or console_uncompressed.html if you're using an uncompressed version of
		 * log4javascript.js), which must be placed in the same directory as your log4javascript.js file.
		 * In general it's simpler to use the document.write method, so unless your page needs to set document.domain,
		 * useDocumentWrite should be set to true.
		 * If not specified, defaults to true.
		 * @param width The width of the console window. Any valid CSS length may be used. If not specified, defaults to 100%.
		 * @param height The height of the console window. Any valid CSS length may be used. If not specified, defaults to 250px.
		 */
		constructor(container: HTMLElement, lazyInit?: boolean, initiallyMinimized?: boolean,
			useDocumentWrite?: boolean, width?: number, height?: number);

		/**
		 * Sets a CSS style property on the HTML element containing the console iframe.
		 */
		addCssProperty(name: string, value: string): void;

		/**
		 * Returns whether the console window is currently visible.
		 */
		isVisible(): boolean;

		/**
		 * Returns whether the console window starts off hidden / minimized.
		 */
		isInitiallyMinimized(): boolean;

		/**
		 * Sets whether the console window should start off hidden / minimized.
		 */
		setInitiallyMinimized(initiallyMinimized: boolean): void;

		/**
		 * Returns whether new log messages are displayed at the top of the pop-up window. Default value is false (i.e. log messages
		 * are appended to the bottom of the window).
		 */
		isNewestMessageAtTop(): boolean;

		/**
		 * Sets whether to display new log messages at the top inside the pop-up window.
		 */
		setNewestMessageAtTop(newestMessageAtTop: boolean): void;

		/**
		 * Returns whether the pop-up window scrolls to display the latest log message when a new message is logged. Default value is true.
		 */
		isScrollToLatestMessage(): boolean;

		/**
		 * Sets whether to scroll the pop-up window to display the latest log message when a new message is logged.
		 */
		setScrollToLatestMessage(scrollToLatestMessage: boolean): void;

		/**
		 * Returns the outer width of the console window.
		 */
		getWidth(): number;

		/**
		 * Sets the outer width of the console window. Any valid CSS length may be used.
		 */
		setWidth(width: number): void;

		/**
		 * Returns the outer height of the console window.
		 */
		getHeight(): number;

		/**
		 * Sets the outer height of the console window. Any valid CSS length may be used.
		 */
		setHeight(height: number): void;

		/**
		 * Returns the largest number of messages displayed and stored by the console window.
		 */
		getMaxMessages(): number;

		/**
		 * Sets the largest number of messages displayed and stored by the console window. Set this to null to make this number unlimited.
		 */
		setMaxMessages(maxMessages: number): void;

		/**
		 * Returns whether the console includes a command line. Default value is true.
		 */
		isShowCommandLine(): boolean;

		/**
		 * Sets whether the console includes a command line.
		 */
		setShowCommandLine(showCommandLine: boolean): void;

		/**
		 * Returns the number of levels to expand when an object value is logged to the console. Each property of an object above
		 * this threshold will be expanded if it is itself an object or array, otherwise its string representation will be displayed.
		 * Default value is 1 (i.e. the properties of the object logged will be displayed in their string representation but not expanded).
		 */
		getCommandLineObjectExpansionDepth(): number;

		/**
		 * Sets the number of levels to expand when an object value is logged to the console.
		 */
		setCommandLineObjectExpansionDepth(expansionDepth: number): void;

		/**
		 * Returns a reference to the window in which commands typed into the command line are currently being executed.
		 */
		getCommandWindow(): Window;

		/**
		 * Sets the window in which commands typed into the command line are executed.
		 */
		setCommandWindow(commandWindow: Window): void;

		/**
		 * Returns the layout used to format the output for commands typed into the command line. The default value is a
		 * PatternLayout with pattern string %m
		 */
		getCommandLayout(): Layout;

		/**
		 * Sets the layout used to format the output for commands typed into the command line.
		 */
		setCommandLayout(commandLayout: Layout): void;

		/**
		 * Clears all messages from the console window.
		 */
		clear(): void;

		/**
		 * Closes the pop-up window.
		 */
		close(): void;

		/**
		 * Shows / unhides the console window.
		 */
		show(): void;

		/**
		 * Hides / minimizes the console window.
		 */
		hide(): void;

		/**
		 * Brings the console window to the top and gives it the focus.
		 */
		focus(): void;

		/**
		 * Brings the console window to the top and gives the focus to the command line.
		 */
		focusCommandLine(): void;

		/**
		 * Brings the console window to the top and gives the focus to the search box.
		 */
		focusSearch(): void;

		/**
		 * Evaluates the expression and appends the result to the console.
		 */
		evalCommandAndAppend(expr: string): void;

		/**
		 * Adds a function with the name specified to the list of functions available on the command line. This feature may be used
		 * to add custom functions to the command line.
		 */
		addCommandLineFunction(functionName: string,
			commandLineFunction: { (appender: Appender, args: any, returnValue: { appendResult: boolean; isError: boolean; }): any; }): void;
	}

	/**
	 * Writes log messages to the browser's built-in console, if present. This only works currently in Safari, Opera and Firefox
	 * with the excellent Firebug extension installed.
	 */
	export class BrowserConsoleAppender extends Appender {
		/**
		 * Constructor
		 */
		constructor();
	}

	//#endregion

	// #region Layouts

	/**
	 * There are a few methods common to all layouts.
	 */
	export class Layout {
		/**
		 * Formats the log message. You should override this method in your own layouts.
		 */
		format(loggingEvent: LoggingEvent): string;

		/**
		 * Returns whether the layout ignores an error object in a logging event passed to its format method.
		 */
		ignoresThrowable(): boolean;

		/**
		 * Returns the content type of the output of the layout.
		 */
		getContentType(): string;

		/**
		 * Returns whether the layout's output is suitable for batching. JsonLayout and XmlLayout are the only built-in layouts that
		 * return true for this method.
		 */
		allowBatching(): boolean;

		/**
		 * Used internally by log4javascript in constructing formatted output for some layouts.
		 */
		getDataValues(loggingEvent: LoggingEvent): Array<any>;

		/**
		 * This method is used to change the default keys used to create formatted name-value pairs for the properties of a log
		 * message, for layouts that do this. These layouts are JsonLayout and HttpPostDataLayout.
		 * @param loggerKey Parameter to use for the log message's logger name. Default is logger.
		 * @param timeStampKey Parameter to use for the log message's timestamp. Default is timestamp.
		 * @param levelKey Parameter to use for the log message's level. Default is level.
		 * @param messageKey Parameter to use for the message itself. Default is message.
		 * @param exceptionKey Parameter to use for the log message's error (exception). Default is exception.
		 * @param urlKey Parameter to use for the current page URL. Default is url.
		 */
		setKeys(loggerKey: string, timeStampKey: string, levelKey: string, messageKey: string, exceptionKey: string, urlKey: string): void;

		/**
		 * Some layouts (JsonLayout, HttpPostDataLayout, PatternLayout and XmlLayout) allow you to set custom fields (e.g. a session
		 * id to send to the server) to the formatted output. Use this method to set a custom field. If there is already a custom
		 * field with the specified name, its value will be updated with value.
		 * @param name Name of the custom property you wish to be included in the formmtted output.
		 * @param value Value of the custom property you wish to be included in the formatted output.
		 */
		setCustomField(name: string, value: string): string;

		/**
		 * Returns whether the layout has any custom fields.
		 */
		hasCustomFields(): boolean;

		formatWithException(loggingEvent: LoggingEvent): string;
	}

	/**
	 * The most basic layout. NullLayout's format() methods performs no formatting at all and simply returns the message logged.
	 */
	export class NullLayout extends Layout {
		/**
		 * Constructor
		 */
		constructor();
	}

	/**
	 * Provides basic formatting. SimpleLayout consists of the level of the log statement, followed by " - " and then the log message
	 * itself. For example, "DEBUG - Hello world".
	 */
	export class SimpleLayout extends Layout {
		/**
		 * Constructor
		 */
		constructor();
	}

	/**
	 * Provides a flexible way of formatting a log message by means of a conversion pattern string. The behaviour of this layout is a
	 * full implementation of PatternLayout in log4j, with the exception of the set of conversion characters - log4javascript's is
	 * necessarily a subset of that of log4j with a few additions of its own, since many of the conversion characters in log4j only
	 * make sense in the context of Java.
	 * The conversion pattern consists of literal text interspersed with special strings starting with a % symbol called conversion
	 * specifiers. A conversion specifier consists of the % symbol, a conversion character (possible characters are listed below) and
	 * format modifiers. For full documentation of the conversion pattern, see log4j's documentation.
	 */
	export class PatternLayout extends Layout {
		/**
		 * Built-in conversion pattern, equivalent to %r %p %c - %m%n.
		 */
		static TTCC_CONVERSION_PATTERN: string;

		/**
		 * Built-in conversion pattern, equivalent to %m%n.
		 */
		static DEFAULT_CONVERSION_PATTERN: string;

		/**
		 * Built-in date format (and also the default), equivalent to yyyy-MM-dd HH:mm:ss,SSS.
		 */
		static ISO8601_DATEFORMAT: string;

		/**
		 * Built-in date format, equivalent to dd MMM YYYY HH:mm:ss,SSS.
		 */
		static DATETIME_DATEFORMAT: string;

		/**
		 * Built-in date format, equivalent to HH:mm:ss,SSS.
		 */
		static ABSOLUTETIME_DATEFORMAT: string;

		/**
		 * Constructor
		 * @param pattern The conversion pattern string to use.
		 */
		constructor(pattern: string);
	}

	/**
	 * Based on log4j's XmlLayout, this layout formats a log message as a fragment of XML.
	 */
	export class XmlLayout extends Layout {
		/**
		 * Constructor
		 * @param combineMessages Whether or not to format multiple log messages as a combined single <log4javascript:message>
		 * element composed of each individual message separated by line breaks or to include a <log4javascript:message> element for
		 * each message inside one <log4javascript:messages> element. If not specified, defaults to true.
		 */
		constructor(combineMessages?: boolean);
	}

	/**
	 * Formats a logging event into JavaScript Object Notation (JSON). JSON is a subset of JavaScript's object literal syntax,
	 * meaning that log messages formatted with this layout can be interpreted directly by JavaScript and converted into objects.
	 * See json.org for more details about JSON.
	 */
	export class JsonLayout extends Layout {
		/**
		 * Constructor
		 * @param readable Whether or not to format each log message with line breaks and tabs. If not specified, defaults to false.
		 * @param combineMessages Whether or not to format multiple log messages as a combined single message property composed of
		 * each individual message separated by line breaks or to format multiple messages as an array. If not specified, defaults to true.
		 */
		constructor(readable?: boolean, combineMessages?: boolean);

		/**
		 * Returns whether or not to each log message is formatted with line breaks and tabs.
		 */
		isReadable(): boolean;
	}

	/**
	 * Formats the log message as a simple URL-encoded string from which a simple server-side script may extract parameters such as
	 * the log message, severity and timestamp. This is the default layout for AjaxAppender.
	 */
	export class HttpPostDataLayout extends Layout {
		/**
		 * Constructor
		 */
		constructor();
	}

	// #endregion

	// #region log4javascript error handling

	/**
	 * log4javascript has a single rudimentary logger-like object of its own to handle messages generated by log4javascript itself.
	 * This logger is called logLog and is accessed via log4javascript.logLog.
	 */
	export namespace logLog {

		/**
		 * Sets whether logLog is in quiet mode or not. In quiet mode, no messages sent to logLog have any visible effect. By default,
		 * quiet mode is switched off.
		 * @param quietMode Whether to turn quiet mode on or off.
		 */
		export function setQuietMode(quietMode: boolean): void;

		/**
		 * Sets how many errors logLog will display alerts for. By default, only the first error encountered generates an alert to the
		 * user. If you turn all errors on by supplying true to this method then all errors will generate alerts.
		 * @param showAllErrors Whether to show all errors or just the first.
		 */
		export function setAlertAllErrors(alertAllErrors: boolean): void;

		/**
		 * Logs a debugging message to an in-memory list.
		 */
		export function debug(message: string, exception?: Error): void;

		/**
		 * Displays an alert of all debugging messages.
		 */
		export function displayDebug(): void;

		/**
		 * Currently has no effect.
		 */
		export function warn(message: string, exception?: Error): void;

		/**
		 * Generates an alert to the user if and only if the error is the first one encountered and setAlertAllErrors(true) has not been called.
		 */
		export function error(message: string, exception?: Error): void;

	}

	// #endregion
}