import { EDecryptionError, ISender, IReceiver, IAnnonymous, IEncryptedMessage } from '@consento/crypto';
import { IEncodable, ITimeoutOptions, IAbortOptions } from '../util';
export * from '@consento/crypto/types';
export interface INotificationsTransport {
    subscribe(receivers: Iterable<IReceiver>, opts?: IAbortOptions): Promise<boolean[]>;
    unsubscribe(receivers: Iterable<IReceiver>, opts?: IAbortOptions): Promise<boolean[]>;
    reset(receivers: Iterable<IReceiver>, opts?: IAbortOptions): Promise<boolean[]>;
    send(channel: IAnnonymous, message: IEncryptedMessage, opts?: IAbortOptions): Promise<any[]>;
}
export interface INotificationControl {
    error(error: Error): void;
    message(receiverIdBase64: string, encryptedMessage: IEncryptedMessage): Promise<boolean | INotificationContentInput | null | undefined>;
    reset(): Promise<void>;
}
export declare type INewNotificationsTransport<TTransport extends INotificationsTransport = INotificationsTransport> = (control: INotificationControl) => TTransport;
export interface INotificationsOptions<TTransport extends INotificationsTransport = INotificationsTransport> {
    transport: INewNotificationsTransport<TTransport>;
    error?: (error: Error) => void;
}
export interface ISubscribeOptions extends ITimeoutOptions {
    force?: boolean;
}
export interface IReceiveOptions<T extends IEncodable> extends ITimeoutOptions {
    filter?: IBodyFilter<T>;
}
export declare enum ENotificationType {
    error = "error",
    success = "success"
}
export declare enum EErrorCode {
    unexpectedReceiver = "unexpected-receiver",
    transportError = "transport-error",
    decryptionFailed = "decryption-failed"
}
export declare type INotificationError = IDecryptionError | IUnexpectedReceiverError | ITransportError | IDecryptionFailedError;
export interface IDecryptionError {
    type: ENotificationType.error;
    code: EDecryptionError;
    receiver: IReceiver;
    channelIdBase64: string;
}
export interface IUnexpectedReceiverError {
    type: ENotificationType.error;
    code: EErrorCode.unexpectedReceiver;
    channelIdBase64: string;
}
export interface ITransportError {
    type: ENotificationType.error;
    code: EErrorCode.transportError;
    error: Error;
}
export interface IDecryptionFailedError {
    type: ENotificationType.error;
    code: EErrorCode.decryptionFailed;
    error: Error;
    channelIdBase64: string;
}
export interface ISuccessNotification<T extends IEncodable = IEncodable> {
    type: 'success';
    body: T;
    receiver: IReceiver;
    channelIdBase64: string;
}
export declare type IAndroidNotificationPriority = 'min' | 'low' | 'default' | 'high' | 'max';
export interface INotificationContentInput {
    title?: string;
    subtitle?: string;
    body?: string;
    data?: {
        [key: string]: unknown;
    };
    badge?: number;
    sound?: boolean | string;
    vibrate?: number[];
    priority?: IAndroidNotificationPriority;
    color?: string;
    autoDismiss?: boolean;
    sticky?: boolean;
    launchImageName?: string;
    attachments?: Array<{
        url: string;
        identifier?: string;
        typeHint?: string;
        hideThumbnail?: boolean;
        thumbnailClipArea?: {
            x: number;
            y: number;
            width: number;
            height: number;
        };
        thumbnailTime?: number;
    }>;
}
export declare type INotification<T extends IEncodable = IEncodable> = INotificationError | ISuccessNotification<T>;
export declare type INotificationProcessor = (message: INotification) => Promise<boolean | INotificationContentInput>;
export declare type IBodyFilter<T extends IEncodable> = (body: IEncodable) => body is T;
export interface IConnection {
    sender: ISender;
    receiver: IReceiver;
}
export interface INotifications<TTransport extends INotificationsTransport = INotificationsTransport> {
    readonly transport: TTransport;
    subscribe(receivers: IReceiver[], opts?: ISubscribeOptions): Promise<boolean[]>;
    unsubscribe(receivers: IReceiver[], opts?: ISubscribeOptions): Promise<boolean[]>;
    reset(receivers: IReceiver[], opts?: ITimeoutOptions): Promise<boolean[]>;
    processors: Set<INotificationProcessor>;
    send(sender: ISender, message: IEncodable, opts?: ITimeoutOptions): Promise<string[]>;
    receive<T extends IEncodable>(receiver: IReceiver, opts?: IReceiveOptions<T>): Promise<{
        afterSubscribe: Promise<T>;
    }>;
    sendAndReceive<T extends IEncodable>(connection: IConnection, message: IEncodable, opts?: IReceiveOptions<T>): Promise<{
        afterSubscribe: Promise<T>;
    }>;
}