declare const SMethodNotImplemented = "Method not implemented.";
declare const SFunction = "function";
/**
 * Description placeholder
 *
 * @interface IMessageName
 * @typedef {IMessageName}
 * @category Messaging
 */
interface IMessageName {
    getName(): string;
}
/**
 * Description placeholder
 *
 * @interface IMessage
 * @typedef {IMessage}
 * @template T
 * @extends {IMessageName}
 * @category Messaging
 */
interface IMessage<T> extends IMessageName {
    readonly value: T;
}
/**
 * Base class from which other classes derive from
 *
 * @abstract
 * @class TMessageBase
 * @typedef {TMessageBase}
 * @template T
 * @implements {IMessage<T>}
 * @implements {IMessageName}
 * @category Messaging
 */
declare abstract class TMessageBase<T> implements IMessage<T>, IMessageName {
    readonly value: T;
    constructor(aValue: T);
    getName(): string;
}
/**
 * Description placeholder
 *
 * @class TMessage
 * @typedef {TMessage}
 * @template T
 * @extends {TMessageBase<T>}
 * @category Messaging
 */
declare class TMessage<T> extends TMessageBase<T> {
}
type SubscriptionIdentifierType = Function | string;
type SubscriptionIndex = number;
export type MessageType = Date | boolean | number | string | {};
/**
 * TMessageManager enables messaging between different code points.
 *
 * @class TMessageManager
 * @typedef {TMessageManager}
 * @category Messaging
 */
declare class TMessageManager {
    private fListeners;
    private fDisabledTypes;
    private static fDefaultManager;
    constructor();
    reset(): void;
    disableType(aType: SubscriptionIdentifierType): void;
    enableType(aType: SubscriptionIdentifierType): void;
    ensureTypeEnabled(aSuffix: string): void;
    typesDisabled(): string[];
    static getDefaultManager(): TMessageManager;
    /**
     * Sends the given message to listeners that subscribes to the given class.
     *
     * @template {MessageType} T
     * @param {SubscriptionIdentifierType} aClass
     * @param {T} aMessage
     * @category Messaging
     */
    sendMessage<T extends MessageType>(aClass: SubscriptionIdentifierType, aMessage: T): void;
    /**
     * Sends a wrapped message to listeners on the given class
     *
     * @template {MessageType} T
     * @param {SubscriptionIdentifierType} aClass
     * @param {TMessage<T>} aMessage
     */
    sendWrappedMessage<T extends MessageType>(aClass: SubscriptionIdentifierType, aMessage: TMessage<T>): void;
    /**
     * Subscribes to the given class and receives the given message
     *
     * @template {MessageType} T
     * @param {SubscriptionIdentifierType} aClass
     * @param {(aMessage: T) => void} aMessageListener
     * @returns {SubscriptionIndex}
     * @category Messaging
     */
    subscribeToMessage<T extends MessageType>(aClass: SubscriptionIdentifierType, aMessageListener: (aMessage: T) => void): SubscriptionIndex;
    /**
     * Subscribes to the wrapped message on the given class
     *
     * @template {MessageType} T
     * @param {SubscriptionIdentifierType} aClass
     * @param {(aMessage: TMessage<T>) => void} aMessageListener
     * @returns {SubscriptionIndex}
     */
    subscribeToWrappedMessage<T extends MessageType>(aClass: SubscriptionIdentifierType, aMessageListener: (aMessage: TMessage<T>) => void): SubscriptionIndex;
    /**
     * Unsubscribes from messages on the given class
     *
     * @public
     * @param {SubscriptionIdentifierType} aClass
     * @param {SubscriptionIndex} aSubscriptionIndex
     * @category Messaging
     */
    unsubscribe(aClass: SubscriptionIdentifierType, aSubscriptionIndex: SubscriptionIndex): void;
    /**
     * Unsubscribes from the wrapped message on the given class
     *
     * @param {SubscriptionIdentifierType} aClass
     * @param {SubscriptionIndex} aSubscriptionIndex
     * @category Messaging
     */
    unsubscribeWrappedMessage(aClass: SubscriptionIdentifierType, aSubscriptionIndex: SubscriptionIndex): void;
}
export { SubscriptionIndex, SubscriptionIdentifierType, TMessage, TMessageManager, SMethodNotImplemented, SFunction };