import { EventDetailMap } from '@genesislcap/foundation-events';
import { InterfaceSymbol } from '@microsoft/fast-foundation';
import { Logger } from '@genesislcap/foundation-logger';

/**
 * Creates a strongly typed broadcast channel.
 *
 * @remarks
 * `registerTypedBroadcastChannel` may be preferred, as it will create and register the channel in the DI.
 *
 * @example
 * ```ts
 * const channel = createTypedBroadcastChannel<GenesisResourcesEvents>(GenesisResourcesChannelId);
 * ```
 * @param name - The channel name.
 * @returns The created TypedBroadcastChannel.
 * @public
 */
export declare const createTypedBroadcastChannel: <TEventDetailMap extends EventDetailMap>(name: string) => DefaultTypedBroadcastChannel<TEventDetailMap>;

/**
 * Default TypedBroadcastChannel implementation.
 * @public
 */
export declare class DefaultTypedBroadcastChannel<TEventDetailMap extends EventDetailMap> extends BroadcastChannel implements TypedBroadcastChannel<TEventDetailMap> {
    /** {@inheritDoc TypedBroadcastChannel.postMessage} */
    postMessage: PostMessage<TEventDetailMap>;
    /** {@inheritDoc TypedBroadcastChannel.isMessageType} */
    isMessageType: <T extends keyof TEventDetailMap>(type: T, event: TypedMessageEvent<TEventDetailMap, keyof TEventDetailMap>) => event is TypedMessageEvent<TEventDetailMap, T>;
}

/**
 * @public
 */
export declare const logger: Logger;

/**
 * @internal
 */
declare type OnMessage<TEventDetailMap extends EventDetailMap> = ((this: BroadcastChannel, ev: TypedMessageEvent<TEventDetailMap, keyof TEventDetailMap>) => any) | null;

/**
 * @internal
 */
declare type OnMessageError<TEventDetailMap extends EventDetailMap> = OnMessage<TEventDetailMap>;

/**
 * @internal
 */
declare type PostMessage<TEventDetailMap extends EventDetailMap> = <K extends keyof TEventDetailMap>(...args: TEventDetailMap[K] extends void ? [type: K] : [type: K, detail: TEventDetailMap[K]]) => void;

/**
 * Creates a dependency injection key for the broadcast channel being registered which is lazily created when injected.
 * @example In a package's config.ts
 * ```ts
 * export interface GenesisResourcesChannel extends TypedBroadcastChannel<GenesisResourcesEvents> {}
 * ...
 * export const GenesisResourcesChannel = registerTypedBroadcastChannel<GenesisResourcesEvents>(GenesisResourcesChannelId);
 * ```
 * @param name - The channel name.
 * @returns The created key.
 * @public
 */
export declare const registerTypedBroadcastChannel: <TEventDetailMap extends EventDetailMap>(name: string) => InterfaceSymbol<TypedBroadcastChannel<TEventDetailMap>>;

/**
 * A TypedBroadcastChannel for sending and receiving typed messages based on {@link @genesislcap/foundation-events#EventDetailMap} input.
 *
 * @example
 * ```ts
 * export type GenesisResourcesEvents = {
 *   'resources-loaded': ResourceItem[];
 *   'resources-unloaded': void;
 * };
 * ...
 * protected channel: TypedBroadcastChannel<GenesisResourcesEvents>;
 * ```
 *
 * See the {@link registerTypedBroadcastChannel} and {@link createTypedBroadcastChannel} APIs below.
 *
 * @public
 */
export declare interface TypedBroadcastChannel<TEventDetailMap extends EventDetailMap> extends Omit<BroadcastChannel, 'postMessage' | 'onmessage' | 'onmessageerror'> {
    /**
     * Post strongly typed messages.
     * @example
     * The event detail map provided to the channel on creation will provide `postMessage` typing.
     * ```ts
     * type GenesisResourcesEvents = {
     *   'resources-loaded': ResourceItem[];
     *   'resources-unloaded': void;
     * };
     * ...
     * channel.postMessage('resources-loaded', this.resources); // ok, as this.resources is an array of ResourceItems.
     * channel.postMessage('resources-loaded'); // not ok, as an array is expected for this message type.
     * channel.postMessage('resources-unloaded'); // ok, as this message type maps to void for its detail.
     * ```
     */
    postMessage: PostMessage<TEventDetailMap>;
    /**
     * On message handler.
     * @example Use the `channel.isMessageType` method to narrow based on message types.
     * ```ts
     * import { GenesisResourcesChannel } from '@genesislcap/foundation-comms';
     * ...
     * @GenesisResourcesChannel protected channel: GenesisResourcesChannel;
     * ...
     * this.channel.onmessage = (ev) => {
     *   if (this.channel.isMessageType('resources-loaded', ev)) {
     *     if (!ev.data.detail.length) {
     *       throw Error('No backend resources available');
     *     }
     *   }
     * };
     * ...
     * this.channel.close();
     * ```
     */
    onmessage: OnMessage<TEventDetailMap>;
    onmessageerror: OnMessageError<TEventDetailMap>;
    /**
     * A type predicate function to narrow down message events based on their 'type' property.
     * @param type - The message type.
     * @param event - The message event.
     */
    isMessageType<T extends keyof TEventDetailMap>(type: T, event: TypedMessageEvent<TEventDetailMap, keyof TEventDetailMap>): event is TypedMessageEvent<TEventDetailMap, T>;
}

/**
 * A TypedMessageEvent for BroadcastChannel transmission.
 * @public
 */
export declare type TypedMessageEvent<TEventDetailMap extends EventDetailMap, T extends keyof TEventDetailMap> = MessageEvent<{
    type: T;
    detail: TEventDetailMap[T];
}>;

export { }