type ObjectKey = string | number | symbol;
type EmptyObject = Record<ObjectKey, never>;
interface BaseBusEvent {
	name: string;
}
interface ListenerOptions<EventList extends BaseBusEvent = BaseBusEvent, EventName extends EventList["name"] = EventList["name"]> {
	/**
	 * Whether a listener should be invoked at most once after being added.
	 * The default value is false.
	 */
	once?: boolean;
	/**
	 * A function that returns a boolean to determine if the listener should be called.
	 * The guard not set by default.
	 *
	 * @since 5.1.0
	 */
	guard?: (event: Extract<EventList, {
		name: EventName;
	}>) => boolean;
	/**
	 * An AbortSignal. The listener will be removed when the abort() method of the AbortController which owns the AbortSignal is called.
	 * See [AbortController](https://developer.mozilla.org/en-US/docs/Web/API/AbortController) for details.
	 *
	 * @since 5.1.0
	 */
	signal?: AbortSignal;
}
type Listener<EventList extends BaseBusEvent, EventName extends EventList["name"]> = (event: Extract<EventList, {
	name: EventName;
}>) => void | Promise<void>;
type AddEventListener<EventList extends BaseBusEvent> = <EventName extends EventList["name"]>(event: EventName, listener: Listener<EventList, EventName>, options?: ListenerOptions<EventList, EventName>) => void;
type RemoveEventListener<EventList extends BaseBusEvent> = <EventName extends EventList["name"]>(event: EventName, listener: Listener<EventList, EventName>) => void;
declare enum ContainerEvent {
	ModuleRegistered = "MODULE_REGISTERED"
}
interface ModuleRegisteredEvent extends BaseBusEvent {
	name: ContainerEvent.ModuleRegistered;
	token: Token<BaseModule>;
}
type ContainerEvents = ModuleRegisteredEvent;
interface Container {
	readonly key: string;
	registerModule: (module: ModuleLoader) => void;
	registerModules: (modules: ModuleLoader[]) => void;
	getModule<Module extends BaseModule>(token: Token<Module>, required?: false): Module | undefined;
	getModule<Module extends BaseModule>(token: Token<Module>, required: true): Module;
	getModuleAsync: <Module extends BaseModule>(token: Token<Module>) => Promise<Module>;
	addEventListener: AddEventListener<ContainerEvents>;
	removeEventListener: RemoveEventListener<ContainerEvents>;
}
interface Token<ModuleType extends BaseModule> {
	name: string;
	module?: ModuleType;
}
interface InitModuleOptions {
	container: Container;
	key: string;
}
interface ModuleLoader<Options = unknown, ModuleType extends BaseModule = BaseModule> {
	token: Token<ModuleType>;
	options: Options;
	required: Token<BaseModule>[];
	setup: (initOptions: InitModuleOptions) => ModuleType;
}
type ModuleFactory<Options, ModuleType extends BaseModule> = Options extends EmptyObject ? () => ModuleLoader<Options, ModuleType> : (options: Options) => ModuleLoader<Options, ModuleType>;
interface BaseModule {
	/**
	 * @hidden
	 */
	container: Container;
}
declare global {
	interface Navigator {
		getBattery?: () => Promise<BatteryManager>;
	}
}
interface BatteryManager extends EventTarget {
	level: number;
	charging: boolean;
	chargingTime: number;
	dischargingTime: number;
}
/**
 * Enum that describes the log levels.
 *
 * @folder Logger
 */
export declare enum LogLevel {
	/**
	 * Debug, info, error, and warning log messages are enabled.
	 */
	Debug = "Debug",
	/**
	 * Info, error, and warning log messages are enabled.
	 */
	Info = "Info",
	/**
	 * Error and warning log messages are enabled.
	 */
	Warning = "Warning",
	/**
	 * Only error messages are enabled.
	 */
	Error = "Error"
}
/**
 * @hidden
 */
export interface LogOptions {
	/**
	 * Log level
	 */
	level?: LogLevel;
	scope: string;
}
/**
 * Interface that represents extra information for a log message.
 *
 * @folder Logger
 */
export interface LogRecordExtraData extends Required<LogOptions> {
	/**
	 * Log message sequence number.
	 */
	sequenceNumber: number;
	/**
	 * Timestamp of the log message.
	 */
	time: string;
	/**
	 * Log message id.
	 */
	traceId: string;
	/**
	 * Log message prefix.
	 */
	prefix?: string | null;
}
/**
 * @hidden
 */
export type ShortLogFunction = (...message: unknown[]) => void;
/**
 * @hidden
 */
export type ScopedLogger = Record<"info" | "debug" | "warn" | "error", ShortLogFunction>;
/**
 * Interface that represents a log message and extra data.
 *
 * @folder Logger
 */
export interface LogCallBackProps {
	/**
	 * Log message.
	 */
	fullMessage: string;
	/**
	 * Log message.
	 */
	message: unknown[];
	/**
	 * Extra information.
	 */
	extraData: LogRecordExtraData;
}
/**
 * Type that represents a callback function to receive the log messages.
 *
 * @interface
 * @folder Logger
 */
export type LogCallbackFunction = (props: LogCallBackProps) => void | Promise<void>;
/**
 * Enum that describes the time formats for the log messages.
 *
 * @folder Logger
 */
export declare enum TimeFormat {
	/**
	 * Unix timestamp.
	 */
	Timestamp = "TIMESTAMP",
	/**
	 * ISO 8601 standard timestamp
	 */
	ISO = "ISO"
}
/**
 * Logger options.
 *
 * @folder Logger
 */
export interface LoggerOptions {
	/**
	 * Log level. The default value is Info.
	 */
	logLevel?: LogLevel;
	/**
	 * Whether logs should be printed to the browser console. The default value is true.
	 */
	enableConsoleLogger?: boolean;
	/**
	 * Log level for the callback function. The default value is Info.
	 */
	callbackLogLevel?: LogLevel;
	/**
	 * Whether a timestamp is included to a log message. The default value is true.
	 */
	withTime?: boolean;
	/**
	 * Timestamp format. The default value is ISO.
	 */
	timeFormat?: TimeFormat;
	/**
	 * Callback function to receive the log messages.
	 */
	onLogCallback?: LogCallbackFunction | null;
	/**
	 * Log message prefix. Helps to distinguish Web SDK logs from other logs in the console. The default value is 'WEBSDK'.
	 */
	prefix?: string | null;
}
/**
 * @hidden
 */
export interface Logger extends BaseModule {
	log: (options: LogOptions, ...message: unknown[]) => void;
	createScopedLogger: (scope: string) => ScopedLogger;
}
/**
 * @hidden
 */
export declare const loggerToken: Token<Logger>;
/**
 * @hidden
 */
export declare const LoggerLoader: ModuleFactory<LoggerOptions, Logger>;

export {};