import { Signal } from "@preact-signals/unified-signals";
import { FlatStore } from "../flat-store";
import { FlatStoreSetter } from "../flat-store/setter";
import { Dispose } from "../hooks/utility";
import { Accessor, AnyReactive, GetTruthyValue, GetValue, Setter } from "../utils";
declare const NO_INIT: unique symbol;
/**
 * A resource that waits for a source to be truthy before fetching.
 */
export interface Unresolved<T> {
    state: "unresolved";
    loading: false;
    error: undefined;
    latest: T | undefined;
    (): undefined;
}
export interface Pending<T> {
    state: "pending";
    loading: true;
    error: undefined;
    latest: T | undefined;
    (): undefined;
}
export interface Ready<T> {
    state: "ready";
    loading: false;
    error: undefined;
    latest: T;
    (): T;
}
export interface Refreshing<T> {
    state: "refreshing";
    loading: true;
    error: undefined;
    latest: T | undefined;
    (): undefined;
}
export interface Errored<T> {
    state: "errored";
    loading: false;
    error: unknown;
    latest: T | undefined;
    (): undefined;
}
export type ResourceState<T> = Unresolved<T> | Pending<T> | Ready<T> | Refreshing<T> | Errored<T>;
export type InitializedResource<T> = Ready<T> | Refreshing<T> | Errored<T>;
export type ResourceActions<TResult, TRefetch = unknown> = {
    mutate: Setter<TResult>;
    refetch: (info?: TRefetch) => TResult | Promise<TResult> | undefined | null;
};
export type ResourceSource<S> = () => S | false | null | undefined;
export type ResourceFetcher<TSourceData, TResult, TRefreshing> = (k: TSourceData, info: ResourceFetcherInfo<TResult, TRefreshing>) => TResult | Promise<TResult>;
export type ResourceFetcherInfo<TSourceData, TRefreshing = unknown> = {
    value: TSourceData | undefined;
    refetching: TRefreshing | boolean;
    /** will be aborted if source is updated or resource disposed */
    signal: AbortSignal;
};
export type ResourceOptions<TResult, TSource extends AnyReactive = Accessor<true>, TRefreshing = boolean, TSourceData extends GetTruthyValue<TSource> = GetTruthyValue<TSource>> = {
    /**
     * Optional. An initial value for the resource. If is provided resource will be in ready state.
     */
    initialValue?: TResult;
    /**
     * Optional. A function or signal that can be used as a source for fetching the resource.
     * This can be useful if you need to base your fetch operation on the value of another signal or even resource
     */
    source?: TSource;
    /**
     * A function that is used to fetch or refresh the resource.
     */
    fetcher: ResourceFetcher<TSourceData, TResult, TRefreshing>;
} & ({
    /**
     * lazy: Optional. If true, the resource will not be fetched until access of ResourceState properties.
     */
    lazy?: boolean;
} | {
    /**
     * Optional. If true, the resource will not subscribe to the source signal, before be activated.
     */
    manualActivation?: boolean;
});
type ResourceStore<TResult, TSource extends AnyReactive> = {
    state: ResourceState<TResult>["state"];
    value: TResult | undefined | typeof NO_INIT;
    error: unknown;
    latest: TResult | undefined;
    readonly source: GetValue<TSource>;
    readonly callResult: TResult | undefined;
};
export type Resource<TResult, TSource extends AnyReactive = Accessor<true>, TRefreshing = boolean, TSourceData extends GetTruthyValue<TSource> = GetTruthyValue<TSource>> = ResourceState<TResult> & {
    /**
     * A function that should be used to activate the resource with manualActivation option enabled.
     */
    activate(): Dispose;
    dispose(): void;
    mutate: ResourceActions<TResult | undefined, TRefreshing>["mutate"];
    refetch: ResourceActions<TResult, TRefreshing>["refetch"];
    /** @internal */
    pr: Promise<TResult> | null;
    /** @internal */
    _state: FlatStore<ResourceStore<TResult, TSource>>;
    /** @internal */
    setter: FlatStoreSetter<ResourceStore<TResult, TSource>>;
    /** @internal */
    abortController: AbortController | null;
    /** @internal */
    _onRead(): void;
    /** @internal */
    manualActivation: boolean;
    /** @internal */
    refreshDummy$: Signal<boolean>;
    /** @internal */
    refetchData: boolean | TRefreshing;
    /** @internal */
    refetchDetector(): {
        source: GetValue<TSource>;
        refetching: TRefreshing | boolean;
    };
    /** @internal */
    refetchEffect: null | (() => void);
    /** @internal */
    fetcher: ResourceFetcher<TSourceData, TResult, TRefreshing>;
    /** @internal */
    get initialized(): boolean;
    /** @internal */
    isInitialValueProvided: boolean;
    /** @internal */
    _read(): ReturnType<ResourceState<TResult>>;
    /** @internal */
    _init(): void;
    /** @internal */
    _fetch(data: {
        source: GetTruthyValue<TSource>;
        refetching: TRefreshing | boolean;
    }): void;
    /** @internal */
    _latest(): TResult | undefined;
    /** @internal */
    _refetch: ResourceActions<TResult, TRefreshing>["refetch"];
    /** @internal */
    _mutate: ResourceActions<TResult | undefined, TRefreshing>["mutate"];
};
/**
 * More preact signals like resource api
 */
export declare const resource: <TResult, TSource extends AnyReactive = Accessor<true>, TRefreshing = boolean, TSourceData extends GetTruthyValue<TSource> = GetTruthyValue<TSource>>(options: ResourceOptions<TResult, TSource, TRefreshing, TSourceData>) => Resource<TResult, TSource, TRefreshing, TSourceData>;
export {};