import type { ApiNotificationMessage } from "./api/ApiMessage";
export type Serializable = string | number | boolean | null | undefined | Serializable[] | SerializableObject;
interface SerializableObject {
    [key: string]: Serializable;
}
export interface RequestContext {
    originDomain?: string;
}
export interface SessionContext {
    connectionId?: string;
    connectionPath?: string;
    langs?: string[];
    identity?: string;
}
interface ContextEvents<R extends RequestContext, S extends SessionContext> {
    enter: {
        context: Context<R, S>;
    };
    exit: {
        context: Context<R, S>;
        exitedContext: Context<R, S>;
    };
    "api:request": {
        domain: string;
        method: string;
        payload: unknown;
        context: Context<R, S>;
    };
    "service:request": {
        domain: string;
        method: string;
        payload: unknown;
        context: Context<R, S>;
    };
    "api:error": {
        error: unknown;
        domain: string;
        method: string;
        payload: unknown;
        context: Context<R, S>;
    };
    "service:error": {
        error: unknown;
        domain: string;
        method: string;
        payload: unknown;
        context: Context<R, S>;
    };
}
export declare const dispatchContextEvent: <K extends keyof ContextEvents<R, S>, R extends RequestContext, S extends SessionContext>(event: K, payload: Omit<ContextEvents<R, S>[K], "context">) => Promise<void>;
declare class Context<R extends RequestContext, S extends SessionContext> {
    readonly id: string;
    state: "current" | "exited" | "detached";
    private _requestContext;
    private _sessionContext;
    readonly parentContext: Context<RequestContext, SessionContext> | undefined;
    private extensions;
    private apiClient;
    constructor(requestContext: R, sessionContext: S, options?: {
        parentContext?: Context<RequestContext, SessionContext>;
        isDetached?: boolean;
    });
    /**
     * Extend the context. This will be run every time the context is referenced.
     * However, each extension will only be applied once.
     */
    extend(extFn: (context: Context<R, S>) => unknown): void;
    get requestContext(): R;
    get sessionContext(): S;
    /**
     * Subscribe the current connection for WS push notifications on the specified topic.
     * @param topic
     */
    subscribe(topic: string, options?: {
        filter?(payload: unknown): boolean;
    }): Promise<void>;
    /**
     * Unsubscribe the current connection from WS push notifications on the specified topic.
     * @param topic
     */
    unsubscribe(topic: string): Promise<void>;
    /**
     * Unsubscribe all connections from WS push notifications on the specified topic.
     * @param topic
     */
    destroyTopic(topic: string): Promise<void>;
    /**
     * Send a notification to the given recipient. The payload must have a `type` attribute.
     * If no recipient is provided, the notification will be sent as a push on the WebSocket
     * connection associated with the current context.
     * @param payload
     * @param recipient
     * @returns
     */
    notify<P extends {
        type: string;
    }>(payload: P, recipient?: ApiNotificationMessage["recipient"]): Promise<void>;
    get<K extends keyof R>(key: K): R[K];
    get<K extends keyof S>(key: K): S[K];
    setRequest<K extends keyof R>(key: K, val: R[K] | null): void;
    setSession<K extends keyof S>(key: K, val: S[K] | null): void;
    merge(sessionContext: SessionContext): void;
    get identity(): S["identity"];
    get domain(): R["originDomain"];
    get langs(): S["langs"];
    get connectionId(): S["connectionId"];
}
export interface ContextFactory<X1, R extends RequestContext, S extends SessionContext> {
    enter(r: R, s: S): Promise<void>;
    exit(): void;
    apply<T>(r: R, s: S, fn: () => Promise<T>): Promise<T>;
    current: Context<R, S> & X1;
    extend<X2>(xFn: (context: Context<R, S>) => X2): ContextFactory<X1 & X2, R, S>;
    on: <K extends keyof ContextEvents<R, S>>(event: K, listener: (payload: ContextEvents<R, S>[K]) => Promise<void>) => void;
}
export declare const createContextFactory: <RX = object, SX = object, R extends RequestContext & RX = RequestContext & RX, S extends SessionContext & SX = SessionContext & SX>(extFn?: (context: Context<R, S>) => unknown) => ContextFactory<object, R, S>;
declare const DefaultContext: ContextFactory<object, RequestContext & object, SessionContext & object>;
export default DefaultContext;