import { Observable, ObservableInput, Subscribable, OperatorFunction } from 'rxjs';

declare const enum RxNotificationKind {
    Suspense = "suspense",
    Next = "next",
    Error = "error",
    Complete = "complete"
}
type RxNotificationValue = 'value' | 'hasValue';
interface RxNextNotification<T> {
    value: T;
    /**
     * @deprecated Instead just check if RxNotificationKind is Next
     */
    hasValue: boolean;
    kind: RxNotificationKind;
    error: boolean;
    complete: boolean;
}
interface RxSuspenseNotification<T> {
    value: T;
    /**
     * @deprecated Instead just check if RxNotificationKind is Next
     */
    hasValue: boolean;
    kind: RxNotificationKind.Suspense;
    error: false;
    complete: false;
}
interface RxErrorNotification<T> {
    value: T;
    /**
     * @deprecated Instead just check if RxNotificationKind is Next
     */
    hasValue: boolean;
    kind: RxNotificationKind.Error;
    error: any;
    complete: false;
}
interface RxCompleteNotification<T> {
    value: T;
    /**
     * @deprecated Instead just check if RxNotificationKind is Next
     */
    hasValue: boolean;
    kind: RxNotificationKind.Complete;
    complete: boolean;
    error: false;
}
type RxNotification<T> = RxNextNotification<T> | RxSuspenseNotification<T> | RxErrorNotification<T> | RxCompleteNotification<T>;

/**
 * @internal
 *
 * @description
 * This factory function returns an object that can be driven imperatively over a `next` method.
 * Internally it prepares the incoming values for rendering by turning them into "template notifications",
 * an extended `ObservableNotification` object used to determine the respective template for values, errors, completing
 *   or suspense states.
 *
 * Internally it handles different edge cases for initial emits. This helps to have or template creation lazy.
 * Also it maps any Observable to RxNotifications. These notifications are bound to the view later and handle the
 *   display of the default template as well as the suspense, error, complete templates.
 */
declare function createTemplateNotifier<U>(): {
    values$: Observable<RxNotification<U>>;
    next(observable: ObservableInput<U> | U | Subscribable<U>): void;
    withInitialSuspense(withInitialSuspense: boolean): void;
};

declare function toRxErrorNotification<T>(error?: any, value?: T): RxErrorNotification<T>;
declare function toRxSuspenseNotification<T>(value?: T): RxSuspenseNotification<T>;
declare function toRxCompleteNotification<T>(value?: T): RxCompleteNotification<T>;

declare function rxMaterialize<T>(): OperatorFunction<T, RxNotification<T>>;

/**
 * @internal
 *
 * A factory function returning an object to handle the process of switching templates by Notification channel.
 * You can next a Observable of `RxNotification` multiple times and merge them into the Observable exposed under `trigger$`
 *
 */
declare function templateTriggerHandling<T>(): {
    trigger$: Observable<RxNotification<T>>;
    next(templateName: Observable<RxNotification<T>>): void;
};

export { RxNotificationKind, createTemplateNotifier, rxMaterialize, templateTriggerHandling, toRxCompleteNotification, toRxErrorNotification, toRxSuspenseNotification };
export type { RxCompleteNotification, RxErrorNotification, RxNextNotification, RxNotification, RxNotificationValue, RxSuspenseNotification };