import * as i0 from '@angular/core';
import { Signal, InjectionToken } from '@angular/core';

type SdTaskMaybeAsync<T> = T | PromiseLike<T>;
type SdTaskStatus = 'idle' | 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
type SdTaskConnectionState = 'idle' | 'connecting' | 'open' | 'reconnecting' | 'closed' | 'error';
interface SdTaskState<TResult = unknown> {
    readonly id: string;
    readonly status: SdTaskStatus;
    readonly progress?: number;
    readonly title?: string;
    readonly message?: string;
    readonly error?: unknown;
    readonly result?: TResult;
    readonly updatedAt?: number | Date;
}
interface SdTaskRetryPolicy {
    readonly maxAttempts?: number;
    readonly initialDelayMs?: number;
    readonly backoff?: number;
    readonly maxDelayMs?: number;
    readonly jitter?: number;
}
interface SdTaskLoadContext<TResult = unknown> {
    readonly id: string;
    readonly signal: AbortSignal;
    readonly attempt: number;
    readonly state: SdTaskState<TResult>;
}
interface SdTaskActionContext<TResult = unknown> {
    readonly id: string;
    readonly state: SdTaskState<TResult>;
}
type SdTaskCancelResult<TResult = unknown> = void | boolean | SdTaskState<TResult>;
type SdTaskCancelHandler<TResult = unknown> = (context: SdTaskActionContext<TResult>) => SdTaskMaybeAsync<SdTaskCancelResult<TResult>>;
interface SdTaskSourceBase<TResult> {
    readonly cancel?: SdTaskCancelHandler<TResult>;
}
interface SdTaskManualSource<TResult = unknown> extends SdTaskSourceBase<TResult> {
    readonly mode: 'manual';
}
interface SdTaskPollingSource<TResult = unknown> extends SdTaskSourceBase<TResult> {
    readonly mode: 'poll';
    readonly load: (context: SdTaskLoadContext<TResult>) => SdTaskMaybeAsync<SdTaskState<TResult>>;
    readonly intervalMs?: number;
    readonly retry?: SdTaskRetryPolicy;
}
interface SdTaskSseSource<TResult = unknown> extends SdTaskSourceBase<TResult> {
    readonly mode: 'sse';
    readonly url: string | (() => string);
    readonly eventSourceInit?: EventSourceInit;
    readonly parse?: (event: MessageEvent<string>) => SdTaskMaybeAsync<SdTaskState<TResult>>;
    readonly retry?: SdTaskRetryPolicy;
}
type SdTaskSource<TResult = unknown> = SdTaskManualSource<TResult> | SdTaskPollingSource<TResult> | SdTaskSseSource<TResult>;
interface SdTaskWatchOptions<TResult = unknown> {
    readonly id: string;
    readonly initialState?: SdTaskState<TResult>;
    readonly source: SdTaskSource<TResult>;
}
interface SdTaskView<TResult = unknown> {
    readonly id: string;
    readonly state: Signal<SdTaskState<TResult>>;
    readonly connection: Signal<SdTaskConnectionState>;
    readonly error: Signal<unknown | null>;
    readonly subscriberCount: Signal<number>;
    readonly canCancel: Signal<boolean>;
    readonly canRetry: Signal<boolean>;
    cancel(): Promise<boolean>;
    retry(): void;
}
interface SdTaskSubscription<TResult = unknown> extends SdTaskView<TResult> {
    readonly destroyed: Signal<boolean>;
    destroy(): void;
}
declare function isSdTaskTerminal(status: SdTaskStatus): boolean;

interface SdTaskEventSource {
    onopen: ((event: Event) => void) | null;
    onmessage: ((event: MessageEvent<string>) => void) | null;
    onerror: ((event: Event) => void) | null;
    close(): void;
}
interface SdTaskEventSourceFactory {
    create(url: string, init?: EventSourceInit): SdTaskEventSource;
}
declare const SD_TASK_EVENT_SOURCE_FACTORY: InjectionToken<SdTaskEventSourceFactory | null>;
declare const SD_TASK_RANDOM: InjectionToken<() => number>;

declare class SdTaskService {
    #private;
    readonly tasks: i0.Signal<SdTaskView<unknown>[]>;
    constructor();
    watch<TResult = unknown>(options: SdTaskWatchOptions<TResult>): SdTaskSubscription<TResult>;
    get<TResult = unknown>(id: string): SdTaskView<TResult> | undefined;
    update<TResult = unknown>(id: string, patch: Partial<Omit<SdTaskState<TResult>, 'id'>>): boolean;
    cancel(id: string): Promise<boolean>;
    retry(id: string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SdTaskService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SdTaskService>;
}

export { SD_TASK_EVENT_SOURCE_FACTORY, SD_TASK_RANDOM, SdTaskService, isSdTaskTerminal };
export type { SdTaskActionContext, SdTaskCancelHandler, SdTaskCancelResult, SdTaskConnectionState, SdTaskEventSource, SdTaskEventSourceFactory, SdTaskLoadContext, SdTaskManualSource, SdTaskMaybeAsync, SdTaskPollingSource, SdTaskRetryPolicy, SdTaskSource, SdTaskSseSource, SdTaskState, SdTaskStatus, SdTaskSubscription, SdTaskView, SdTaskWatchOptions };