import { Injector, Signal, Type, WritableSignal } from '@angular/core';
import { ConsoleLike } from './interface';
import { Observable } from 'rxjs';
import { DeferQueueItemPriority } from './util';
import * as i0 from "@angular/core";
export interface DeferQueueServiceOptions {
    timeout: number;
    identifier?: string;
}
export interface DeferQueueDeferrable {
    triggered: WritableSignal<boolean>;
    resolve: (err?: Error) => void;
}
export interface DeferQueueItem extends DeferQueueServiceOptions {
    priority: DeferQueueItemPriority;
    identifier?: string;
    resolved: () => Promise<unknown>;
    timeCreated: number;
    logger: ConsoleLike;
}
export interface SignalState<V> {
    value: Signal<V>;
}
export interface ObservableState<V> {
    value$: Observable<V>;
}
export declare class DeferQueue {
    private readonly queueProcessor;
    private readonly bailout;
    private readonly timeout;
    private readonly logger;
    private readonly queue;
    private readonly deferrableStore;
    get view(): {
        when: (identifier: string, priority?: DeferQueueItemPriority) => boolean;
        resolve: (identifier: string, err?: Error | undefined) => void;
    };
    private when;
    private resolve;
    /**
     * Creates a new deferrable queue item, and adds it to the queue. if an item with this identifier already exists, the existing item will be returned.
     * @param identifier is used to connect the resolved item to the defer-trigger
     * @param priority higher priority will resolve the deferrable earlier
     *
     */
    private deferrable;
    state<V, T extends SignalState<V>>(initialValue: V, dynamicImport: () => Promise<Type<T>>, priority?: DeferQueueItemPriority, injector?: Injector): Signal<V>;
    state$<V, T extends ObservableState<V>>(initialValue: V, dynamicImport: () => Promise<Type<T>>, priority?: DeferQueueItemPriority, injector?: Injector): Observable<V>;
    service$<T>(dynamicImport: () => Promise<Type<T>>, priority?: DeferQueueItemPriority, injector?: Injector): Observable<T>;
    serviceAsync<T>(dynamicImport: () => Promise<Type<T>>, priority?: DeferQueueItemPriority, injector?: Injector): Promise<T>;
    service<T>(dynamicImport: () => Promise<Type<T>>, priority?: DeferQueueItemPriority, injector?: Injector): Signal<T | null>;
    private serviceItem;
    private createQueueItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeferQueue, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DeferQueue>;
}