import { createStore } from 'effector';
import { Effect } from 'effector';
import { Event as Event_2 } from 'effector';
import { EventCallable } from 'effector';
import { EventPayload } from 'effector';
import { Json } from 'effector';
import { Store } from 'effector';
import { StoreWritable } from 'effector';
import { Subscription } from 'effector';

declare const ABORT = "ABORT";

export declare interface AbortError extends FarfetchedError<typeof ABORT> {
}

export declare function abortError(): AbortError;

declare type ApiRequestError = ConfigurationError | TimeoutError | PreparationError | NetworkError | HttpError;

/**
 * Applies the Barrier to the Query or Mutation. After operation start it checks the Barrier .$active status and postpones the execution if the Barrier is active. After the Barrier is deactivated, it resumes the execution of the operation.
 *
 * @param operation Query or Mutation to apply Barrier to
 * @param config.barrier Barrier to apply
 */
export declare function applyBarrier(operation: RemoteOperation<any, any, any, any, any>, { barrier }: {
    barrier: Barrier;
}): void;

/**
 * Applies the Barrier to the Query or Mutation. After operation start it checks the Barrier .$active status and postpones the execution if the Barrier is active. After the Barrier is deactivated, it resumes the execution of the operation.
 *
 * @param operations Query or Mutation to apply Barrier to
 * @param config.barrier Barrier to apply
 */
export declare function applyBarrier(operations: RemoteOperation<any, any, any, any, any>[], { barrier }: {
    barrier: Barrier;
}): void;

export declare function attachObservability({ adapter, options, events, }: {
    adapter: CacheAdapterInstance;
    options?: CacheAdapterOptions['observability'];
    events?: {
        itemExpired?: Event_2<{
            key: string;
            value: unknown;
        }>;
        itemEvicted?: Event_2<{
            key: string;
        }>;
    };
}): void;

export declare type Barrier = {
    /**
     * Is Barrier active?
     */
    $active: Store<boolean>;
    /**
     * Event that triggers every time when Barrier is activated or active Barrier is touched
     */
    activated: Event_2<void>;
    /**
     * Event that triggers every time when Barrier is deactivated or inactive Barrier is touched
     */
    deactivated: Event_2<void>;
    /**
     * Event that triggers every time when all Barrier's performers are finished
     */
    performed: Event_2<void>;
    /**
     * Event that can be called to forcely deactivate Barrier
     */
    forceDeactivate: EventCallable<void>;
    /**
     * Semi-private properties, you have to avoid using them
     */
    __: {
        /**
         * Call this event every time when operation with applied Barrier tries to start
         */
        touch: EventCallable<void>;
        /**
         * Call this event every time when operation with applied Barrier fails
         */
        operationFailed: EventCallable<{
            params: unknown;
            error: unknown;
        }>;
        /**
         * Call this event every time when operation with applied Barrier succeeds
         */
        operationDone: EventCallable<{
            params: unknown;
            result: unknown;
        }>;
        /**
         * Barrier ia based on Mutex, this store provides direct access to it
         */
        $mutex: Store<Mutex | null>;
    };
};

declare interface BaseJsonMutationConfigNoParams<Data, BodySource, QuerySource, HeadersSource, UrlSource> extends SharedMutationFactoryConfig {
    request: RequestConfig_2<void, BodySource, QuerySource, HeadersSource, UrlSource>;
}

declare interface BaseJsonMutationConfigWithParams<Params, Data, BodySource, QuerySource, HeadersSource, UrlSource> extends SharedMutationFactoryConfig {
    params: ParamsDeclaration<Params>;
    request: RequestConfig_2<Params, BodySource, QuerySource, HeadersSource, UrlSource>;
}

declare interface BaseJsonQueryConfigNoParams<Data, BodySource, QuerySource, HeadersSource, UrlSource> extends SharedQueryFactoryConfig<Data> {
    request: RequestConfig<void, BodySource, QuerySource, HeadersSource, UrlSource>;
}

declare interface BaseJsonQueryConfigWithParams<Params, Data, BodySource, QuerySource, HeadersSource, UrlSource> extends SharedQueryFactoryConfig<Data> {
    params: ParamsDeclaration<Params>;
    request: RequestConfig<Params, BodySource, QuerySource, HeadersSource, UrlSource>;
}

export declare function cache<Q extends Query<any, any, any, any>>(query: Q, rawParams?: CacheParameters): void;

export declare interface CacheAdapter extends CacheAdapterInstance {
    __: {
        $instance: StoreWritable<CacheAdapterInstance>;
    };
}

declare interface CacheAdapterInstance {
    get: Effect<{
        key: string;
    }, {
        value: unknown;
        cachedAt: number;
    } | null>;
    set: Effect<{
        key: string;
        value: unknown;
    }, void>;
    purge: EventCallable<void>;
    unset: Effect<{
        key: string;
    }, void>;
}

export declare interface CacheAdapterOptions {
    maxEntries?: number;
    maxAge?: Time;
    observability?: {
        hit?: EventCallable<{
            key: string;
        }>;
        miss?: EventCallable<{
            key: string;
        }>;
        expired?: EventCallable<{
            key: string;
        }>;
        evicted?: EventCallable<{
            key: string;
        }>;
    };
}

declare interface CacheParameters {
    adapter?: CacheAdapter;
    staleAfter?: Time;
    purge?: Event_2<void>;
    humanReadableKeys?: boolean;
}

declare type Callback<Data, Result> = (data: Data) => Result;

declare type CallbackWithSource<Data, Result, Source> = {
    source: Store<Source>;
    fn: (data: Data, source: Source) => Result;
};

declare type CallObject = {
    id: string;
    /**
     * Rejectes promise with provided error and ignores rest of the handler
     *
     * @param error - Error to reject promise with, defaults to `OperationAborted` error
     */
    abort: (customError?: unknown) => void;
    /**
     * Status of the call
     *
     * For sync calls it is always `finished`
     */
    status: 'pending' | 'finished';
    /**
     * Promise of async handler calls,
     * it is resolved or rejected when handler is finished
     *
     * For sync handlers it is not presented
     */
    promise?: Promise<unknown>;
};

export declare function combineSourced<R extends Record<string, SourcedField<any, any, any>>, S>(config: R, mapper?: (v: {
    [Key in keyof R]: R[Key] extends SourcedField<any, infer D, any> ? D : never;
}) => S): CallbackWithSource<unknown, S, unknown>;

/**
 * @param op Query or Mutation to apply concurrency to
 * @param config.strategy  Auto-cancelation strategy
 * - `TAKE_EVERY` will not cancel any requests
 * - `TAKE_LATEST` will cancel all but the latest request
 * - `TAKE_FIRST` will ignore all but the first request
 * @param config.abortAll All requests will be aborted on this event call
 */
export declare function concurrency(op: RemoteOperation<any, any, any, any>, { strategy, abortAll, }: {
    strategy?: 'TAKE_LATEST' | 'TAKE_EVERY' | 'TAKE_FIRST';
    abortAll?: Event_2<any>;
}): RemoteOperation<any, any, any, any, {}>;

declare const CONFIGURATION = "CONFIGURATION";

export declare interface ConfigurationError extends FarfetchedError<typeof CONFIGURATION> {
    validationErrors: string[];
}

export declare function configurationError(config: {
    reason: string;
    validationErrors: string[];
}): ConfigurationError;

export declare function connectQuery<Sources, Target extends Query<any, any, any, any>>(args: {
    source: Sources;
    target: Target | [...Target[]];
} & (Target extends Query<infer P, any, any, any> ? P extends void ? {
    fn?: undefined;
    filter?: () => boolean;
} : Sources extends Query<any, any, any, any> ? {
    fn: (sources: {
        result: RemoteOperationResult<Sources>;
        params: RemoteOperationParams<Sources>;
    }) => {
        params: RemoteOperationParams<Target>;
    };
    filter?: (sources: {
        result: RemoteOperationResult<Sources>;
        params: RemoteOperationParams<Sources>;
    }) => boolean;
} : Sources extends Record<string, Query<any, any, any, any>> ? {
    fn: (sources: {
        [index in keyof Sources]: {
            result: RemoteOperationResult<Sources[index]>;
            params: RemoteOperationParams<Sources[index]>;
        };
    }) => {
        params: RemoteOperationParams<Target>;
    };
    filter?: (sources: {
        [index in keyof Sources]: {
            result: RemoteOperationResult<Sources[index]>;
            params: RemoteOperationParams<Sources[index]>;
        };
    }) => boolean;
} : NonExtendable : NonExtendable)): void;

export declare interface Contract<Raw, Data extends Raw> {
    /**
     * Checks if Raw is some Data
     */
    isData: (prepared: Raw) => prepared is Data;
    /**
     * - empty array is dedicated for valid response
     * - array of string with validation erorrs for invalidDataError
     */
    getErrorMessages: (prepared: Raw) => string[];
}

/**
 * Creates new Barrier
 * @param config.active Store that holds the Barrier status
 * @param config.perform Array of Performers that should be started when active Barrier is touched
 */
export declare function createBarrier(config: {
    active: Store<boolean>;
    perform?: Array<Performer>;
}): Barrier;

/**
 * Creates new Barrier
 * @param config.activateOn Event that will activate Barrier
 * @param config.deactivateOn Event that will deactivate Barrier
 */
export declare function createBarrier(config: {
    activateOn: Event_2<any>;
    deactivateOn: Event_2<any>;
}): Barrier;

/**
 * Creates new Barrier
 * @param config.activateOn.failure A function that will be called every time when operation with applied Barrier fails. If it returns true, Barrier will be activated.
 * @param config.perform Array of Performers that should be started when active Barrier is touched
 */
export declare function createBarrier(config: {
    activateOn: {
        failure: (options: {
            params: unknown;
            error: unknown;
        }) => boolean;
    };
    perform: Array<Performer>;
}): Barrier;

export declare function createCacheAdapter(adapter: CacheAdapterInstance): CacheAdapter;

export declare function createHeadlessMutation<Params, Data, ContractData extends Data, MappedData, Error, MappedError = Error | InvalidDataError, MapDataSource = void, MapErrorSource = void, ValidationSource = void>(config: SharedMutationFactoryConfig & {
    contract: Contract<Data, ContractData>;
    validate?: Validator<ContractData, Params, ValidationSource>;
    mapData: DynamicallySourcedField<{
        result: ContractData;
        params: Params;
    }, MappedData, MapDataSource>;
    mapError?: DynamicallySourcedField<{
        error: Error | InvalidDataError;
        params: Params;
        headers?: Headers;
    }, MappedError, MapErrorSource>;
}): Mutation<Params, MappedData, MappedError>;

/**
 * Creates Query without any executor, it cannot be used as-is.
 *
 * @example
 * const headlessQuery = createHeadlessQuery()
 * headlessQuery.__.executeFx.use(someHandler)
 */
export declare function createHeadlessQuery<Params, Response, Error, ContractData extends Response, MappedData, MappedError = Error | InvalidDataError, MapDataSource = void, mapErrorSource = void, ValidationSource = void, Initial = null>(config: {
    initialData?: Initial;
    contract: Contract<Response, ContractData>;
    mapData: DynamicallySourcedField<{
        result: ContractData;
        params: Params;
    }, MappedData, MapDataSource>;
    mapError?: DynamicallySourcedField<{
        error: Error | InvalidDataError;
        params: Params;
        headers?: Headers;
    }, MappedError, mapErrorSource>;
    validate?: Validator<ContractData, Params, ValidationSource>;
    sourced?: SourcedField<Params, unknown, unknown>[];
    paramsAreMeaningless?: boolean;
} & SharedQueryFactoryConfig<MappedData, Initial>): Query<Params, MappedData, MappedError, Initial>;

export declare function createJsonMutation<Params, Data, TransformedData, BodySource = void, QuerySource = void, HeadersSource = void, UrlSource = void, DataSource = void, MappedError = JsonApiRequestError, FailureSource = void, ValidationSource = void>(config: BaseJsonMutationConfigWithParams<Params, TransformedData, BodySource, QuerySource, HeadersSource, UrlSource> & {
    response: {
        contract: Contract<unknown, Data>;
        mapData: DynamicallySourcedField<{
            result: Data;
            params: Params;
            headers?: Headers;
        }, TransformedData, DataSource>;
        mapError?: DynamicallySourcedField<{
            error: JsonApiRequestError;
            params: Params;
            headers?: Headers;
        }, MappedError, FailureSource>;
        validate?: Validator<TransformedData, Params, ValidationSource>;
        status?: {
            expected: number | number[];
        };
    };
}): Mutation<Params, TransformedData, MappedError>;

export declare function createJsonMutation<Params, Data, BodySource = void, QuerySource = void, HeadersSource = void, UrlSource = void, MappedError = JsonApiRequestError, FailureSource = void, ValidationSource = void>(config: BaseJsonMutationConfigWithParams<Params, Data, BodySource, QuerySource, HeadersSource, UrlSource> & {
    response: {
        contract: Contract<unknown, Data>;
        mapError?: DynamicallySourcedField<{
            error: JsonApiRequestError;
            params: Params;
            headers?: Headers;
        }, MappedError, FailureSource>;
        validate?: Validator<Data, Params, ValidationSource>;
        status?: {
            expected: number | number[];
        };
    };
}): Mutation<Params, Data, MappedError>;

export declare function createJsonMutation<Data, TransformedData, BodySource = void, QuerySource = void, HeadersSource = void, UrlSource = void, DataSource = void, MappedError = JsonApiRequestError, FailureSource = void, ValidationSource = void>(config: BaseJsonMutationConfigNoParams<TransformedData, BodySource, QuerySource, HeadersSource, UrlSource> & {
    response: {
        contract: Contract<unknown, Data>;
        mapData: DynamicallySourcedField<{
            result: Data;
            params: void;
            headers?: Headers;
        }, TransformedData, DataSource>;
        mapError?: DynamicallySourcedField<{
            error: JsonApiRequestError;
            params: void;
            headers?: Headers;
        }, MappedError, FailureSource>;
        validate?: Validator<TransformedData, void, ValidationSource>;
        status?: {
            expected: number | number[];
        };
    };
}): Mutation<void, TransformedData, MappedError>;

export declare function createJsonMutation<Data, BodySource = void, QuerySource = void, HeadersSource = void, UrlSource = void, MappedError = JsonApiRequestError, FailureSource = void, ValidationSource = void>(config: BaseJsonMutationConfigNoParams<Data, BodySource, QuerySource, HeadersSource, UrlSource> & {
    response: {
        contract: Contract<unknown, Data>;
        mapError?: DynamicallySourcedField<{
            error: JsonApiRequestError;
            params: void;
            headers?: Headers;
        }, MappedError, FailureSource>;
        validate?: Validator<Data, void, ValidationSource>;
        status?: {
            expected: number | number[];
        };
    };
}): Mutation<void, Data, MappedError>;

export declare function createJsonQuery<Params, Data, TransformedData, BodySource = void, QuerySource = void, HeadersSource = void, UrlSource = void, DataSource = void, MappedError = JsonApiRequestError, FailureSource = void, ValidationSource = void>(config: BaseJsonQueryConfigWithParams<Params, TransformedData, BodySource, QuerySource, HeadersSource, UrlSource> & {
    response: {
        contract: Contract<unknown, Data>;
        mapData: DynamicallySourcedField<{
            result: Data;
            params: Params;
            headers?: Headers;
        }, TransformedData, DataSource>;
        mapError?: DynamicallySourcedField<{
            error: JsonApiRequestError;
            params: Params;
            headers?: Headers;
        }, MappedError, FailureSource>;
        validate?: Validator<TransformedData, Params, ValidationSource>;
    };
}): Query<Params, TransformedData, MappedError>;

export declare function createJsonQuery<Params, Data, TransformedData, BodySource = void, QuerySource = void, HeadersSource = void, UrlSource = void, DataSource = void, MappedError = JsonApiRequestError, FailureSource = void, ValidationSource = void>(config: BaseJsonQueryConfigWithParams<Params, TransformedData, BodySource, QuerySource, HeadersSource, UrlSource> & {
    initialData?: TransformedData;
    response: {
        contract: Contract<unknown, Data>;
        mapData: DynamicallySourcedField<{
            result: Data;
            params: Params;
            headers?: Headers;
        }, TransformedData, DataSource>;
        mapError?: DynamicallySourcedField<{
            error: JsonApiRequestError;
            params: Params;
            headers?: Headers;
        }, MappedError, FailureSource>;
        validate?: Validator<TransformedData, Params, ValidationSource>;
    };
}): Query<Params, TransformedData, MappedError, TransformedData>;

export declare function createJsonQuery<Params, Data, BodySource = void, QuerySource = void, HeadersSource = void, UrlSource = void, MappedError = JsonApiRequestError, FailureSource = void, ValidationSource = void>(config: BaseJsonQueryConfigWithParams<Params, Data, BodySource, QuerySource, HeadersSource, UrlSource> & {
    response: {
        contract: Contract<unknown, Data>;
        mapError?: DynamicallySourcedField<{
            error: JsonApiRequestError;
            params: Params;
            headers?: Headers;
        }, MappedError, FailureSource>;
        validate?: Validator<Data, Params, ValidationSource>;
    };
}): Query<Params, Data, MappedError>;

export declare function createJsonQuery<Params, Data, BodySource = void, QuerySource = void, HeadersSource = void, UrlSource = void, MappedError = JsonApiRequestError, FailureSource = void, ValidationSource = void>(config: BaseJsonQueryConfigWithParams<Params, Data, BodySource, QuerySource, HeadersSource, UrlSource> & {
    initialData?: Data;
    response: {
        contract: Contract<unknown, Data>;
        mapError?: DynamicallySourcedField<{
            error: JsonApiRequestError;
            params: Params;
            headers?: Headers;
        }, MappedError, FailureSource>;
        validate?: Validator<Data, Params, ValidationSource>;
    };
}): Query<Params, Data, MappedError, Data>;

export declare function createJsonQuery<Data, TransformedData, BodySource = void, QuerySource = void, HeadersSource = void, UrlSource = void, DataSource = void, MappedError = JsonApiRequestError, FailureSource = void, ValidationSource = void>(config: BaseJsonQueryConfigNoParams<TransformedData, BodySource, QuerySource, HeadersSource, UrlSource> & {
    response: {
        contract: Contract<unknown, Data>;
        mapData: DynamicallySourcedField<{
            result: Data;
            params: void;
            headers?: Headers;
        }, TransformedData, DataSource>;
        mapError?: DynamicallySourcedField<{
            error: JsonApiRequestError;
            params: void;
            headers?: Headers;
        }, MappedError, FailureSource>;
        validate?: Validator<TransformedData, void, ValidationSource>;
    };
}): Query<void, TransformedData, MappedError>;

export declare function createJsonQuery<Data, TransformedData, BodySource = void, QuerySource = void, HeadersSource = void, UrlSource = void, DataSource = void, MappedError = JsonApiRequestError, FailureSource = void, ValidationSource = void>(config: BaseJsonQueryConfigNoParams<TransformedData, BodySource, QuerySource, HeadersSource, UrlSource> & {
    initialData?: TransformedData;
    response: {
        contract: Contract<unknown, Data>;
        mapData: DynamicallySourcedField<{
            result: Data;
            params: void;
            headers?: Headers;
        }, TransformedData, DataSource>;
        mapError?: DynamicallySourcedField<{
            error: JsonApiRequestError;
            params: void;
            headers?: Headers;
        }, MappedError, FailureSource>;
        validate?: Validator<TransformedData, void, ValidationSource>;
    };
}): Query<void, TransformedData, MappedError, TransformedData>;

export declare function createJsonQuery<Data, BodySource = void, QuerySource = void, HeadersSource = void, UrlSource = void, MappedError = JsonApiRequestError, FailureSource = void, ValidationSource = void>(config: BaseJsonQueryConfigNoParams<Data, BodySource, QuerySource, HeadersSource, UrlSource> & {
    response: {
        contract: Contract<unknown, Data>;
        mapError?: DynamicallySourcedField<{
            error: JsonApiRequestError;
            params: void;
            headers?: Headers;
        }, MappedError, FailureSource>;
        validate?: Validator<Data, void, ValidationSource>;
    };
}): Query<void, Data, MappedError>;

export declare function createJsonQuery<Data, BodySource = void, QuerySource = void, HeadersSource = void, UrlSource = void, MappedError = JsonApiRequestError, FailureSource = void, ValidationSource = void>(config: BaseJsonQueryConfigNoParams<Data, BodySource, QuerySource, HeadersSource, UrlSource> & {
    initialData?: Data;
    response: {
        contract: Contract<unknown, Data>;
        mapError?: DynamicallySourcedField<{
            error: JsonApiRequestError;
            params: void;
            headers?: Headers;
        }, MappedError, FailureSource>;
        validate?: Validator<Data, void, ValidationSource>;
    };
}): Query<void, Data, MappedError, Data>;

export declare function createMutation<Params, Data>(config: {
    handler: (params: Params) => Promise<Data>;
} & SharedMutationFactoryConfig): Mutation<Params, Data, unknown>;

export declare function createMutation<Params, Data, Error>(config: {
    effect: Effect<Params, Data, Error>;
} & SharedMutationFactoryConfig): Mutation<Params, Data, Error>;

export declare function createMutation<Params, Data, Error, MappedError, MapErrorSource = void>(config: {
    effect: Effect<Params, Data, Error>;
    mapError: DynamicallySourcedField<{
        error: Error;
        params: Params;
    }, MappedError, MapErrorSource>;
} & SharedMutationFactoryConfig): Mutation<Params, Data, MappedError>;

export declare function createMutation<Params, Data, ContractData extends Data, Error>(config: {
    effect: Effect<Params, Data, Error>;
    contract: Contract<Data, ContractData>;
} & SharedMutationFactoryConfig): Mutation<Params, ContractData, Error | InvalidDataError>;

export declare function createMutation<Params, Data, ContractData extends Data, Error, MappedError, MapErrorSource = void>(config: {
    effect: Effect<Params, Data, Error>;
    contract: Contract<Data, ContractData>;
    mapError: DynamicallySourcedField<{
        error: Error | InvalidDataError;
        params: Params;
    }, MappedError, MapErrorSource>;
} & SharedMutationFactoryConfig): Mutation<Params, ContractData, MappedError>;

export declare function createQuery<Params extends any[], Response>(config: {
    handler: (...p: Params) => Promise<Response>;
} & SharedQueryFactoryConfig<Response>): Query<OptionalParams<Params>, Response, unknown>;

export declare function createQuery<Params extends any[], Response>(config: {
    initialData: Response;
    handler: (...p: Params) => Promise<Response>;
} & SharedQueryFactoryConfig<Response>): Query<OptionalParams<Params>, Response, unknown, Response>;

export declare function createQuery<Params, Response, Error, MappedData, MapDataSource = void, ValidationSource = void>(config: {
    effect: Effect<Params, Response, Error>;
    mapData: DynamicallySourcedField<{
        result: Response;
        params: Params;
    }, MappedData, MapDataSource>;
    validate?: Validator<MappedData, Params, ValidationSource>;
} & SharedQueryFactoryConfig<MappedData>): Query<Params, MappedData, Error>;

export declare function createQuery<Params, Response, Error>(config: {
    effect: Effect<Params, Response, Error>;
} & SharedQueryFactoryConfig<Response>): Query<Params, Response, Error>;

export declare function createQuery<Params, Response, Error>(config: {
    initialData: Response;
    effect: Effect<Params, Response, Error>;
} & SharedQueryFactoryConfig<Response>): Query<Params, Response, Error, Response>;

export declare function createQuery<Params, Response, Error, ContractData extends Response, ValidationSource = void>(config: {
    effect: Effect<Params, Response, Error>;
    contract: Contract<Response, ContractData>;
    validate?: Validator<ContractData, Params, ValidationSource>;
} & SharedQueryFactoryConfig<ContractData>): Query<Params, ContractData, Error | InvalidDataError>;

export declare function createQuery<Params, Response, Error, ContractData extends Response, ValidationSource = void>(config: {
    initialData: ContractData;
    effect: Effect<Params, Response, Error>;
    contract: Contract<Response, ContractData>;
    validate?: Validator<ContractData, Params, ValidationSource>;
} & SharedQueryFactoryConfig<ContractData>): Query<Params, ContractData, Error | InvalidDataError, ContractData>;

export declare function createQuery<Params, Response, Error, MappedData, MapDataSource = void, ValidationSource = void>(config: {
    initialData: MappedData;
    effect: Effect<Params, Response, Error>;
    mapData: DynamicallySourcedField<{
        result: Response;
        params: Params;
    }, MappedData, MapDataSource>;
    validate?: Validator<MappedData, Params, ValidationSource>;
} & SharedQueryFactoryConfig<MappedData>): Query<Params, MappedData, Error, MappedData>;

export declare function createQuery<Params, Response, Error, ContractData extends Response, MappedData, MapDataSource = void, ValidationSource = void>(config: {
    effect: Effect<Params, Response, Error>;
    contract: Contract<Response, ContractData>;
    mapData: DynamicallySourcedField<{
        result: ContractData;
        params: Params;
    }, MappedData, MapDataSource>;
    validate?: Validator<ContractData, Params, ValidationSource>;
} & SharedQueryFactoryConfig<MappedData>): Query<Params, MappedData, Error | InvalidDataError>;

export declare function createQuery<Params, Response, Error, ContractData extends Response, MappedData, MapDataSource = void, ValidationSource = void>(config: {
    initialData: MappedData;
    effect: Effect<Params, Response, Error>;
    contract: Contract<Response, ContractData>;
    mapData: DynamicallySourcedField<{
        result: ContractData;
        params: Params;
    }, MappedData, MapDataSource>;
    validate?: Validator<ContractData, Params, ValidationSource>;
} & SharedQueryFactoryConfig<MappedData>): Query<Params, MappedData, Error | InvalidDataError, MappedData>;

declare type DataSource<Params> = {
    name: string;
    get: Effect<{
        params: Params;
    }, {
        result: unknown;
        stale: boolean;
        meta?: unknown;
    } | null, unknown>;
    set?: Effect<{
        params: Params;
        result: unknown;
    }, void, unknown>;
    unset?: Effect<{
        params: Params;
    }, void, unknown>;
};

export declare function declareParams<T>(): ParamsDeclaration<T>;

declare interface DefaultMeta {
    name: string;
    flags: Record<string, boolean>;
    $callObjects?: Store<CallObject[]>;
}

declare interface DelayOptions_2 {
    randomize: {
        spread: number;
    };
}

export declare type DynamicallySourcedField<Data, Result, Source> = Callback<Data, Result> | CallbackWithSource<Data, Result, Source>;

export declare interface ExecutionMeta {
    stopErrorPropagation: boolean;
    stale: boolean;
}

export declare function exponentialDelay(base: number, opts?: DelayOptions_2): ({ attempt }: RetryMeta) => number;

declare type FailInfo<Q extends RemoteOperation<any, any, any, any>> = {
    params: RemoteOperationParams<Q>;
    error: RemoteOperationError<Q>;
    meta: ExecutionMeta;
};

export declare type FarfetchedError<T extends string> = {
    errorType: T;
    explanation: string;
};

export declare type FetchApiRecord = Record<string, string | string[] | number | boolean | null | undefined>;

/**
 * Effect wrapper for Fetch API
 *
 * It's used to declare static type of Error and mock requests in tests
 */
export declare const fetchFx: Effect<Request, Response, TypeError>;

export declare type FetchingStatus = 'initial' | 'pending' | 'done' | 'fail';

export declare type FetchOptions = Omit<RequestInit, 'method' | 'headers' | 'body' | 'signal'>;

declare type Hour = `${number}${HourUnit}`;

declare type HourUnit = 'h' | 'hr' | 'hrs' | 'hour' | 'hours';

declare const HTTP = "HTTP";

export declare interface HttpError<Status extends number = number> extends FarfetchedError<typeof HTTP> {
    status: Status;
    statusText: string;
    response: string | Json | null;
}

export declare function httpError(config: {
    status: number;
    statusText: string;
    response: string | Json | null;
}): HttpError;

declare type HttpMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'QUERY' | 'OPTIONS';

export declare function inMemoryCache(config?: CacheAdapterOptions): CacheAdapter;

declare const INVALID_DATA = "INVALID_DATA";

export declare interface InvalidDataError extends FarfetchedError<typeof INVALID_DATA> {
    validationErrors: string[];
    response: unknown;
}

export declare function invalidDataError(config: {
    validationErrors: string[];
    response: unknown;
}): InvalidDataError;

export declare function isHttpError(args: WithError): args is WithError<HttpError>;

export declare function isHttpErrorCode<Code extends number>(code: Code | Code[]): (args: WithError) => args is WithError<HttpError<Code>, Record<string, unknown>>;

export declare function isInvalidDataError(args: WithError): args is WithError<InvalidDataError>;

export declare function isNetworkError(args: WithError): args is WithError<NetworkError>;

export declare function isPreparationError(args: WithError): args is WithError<PreparationError>;

export declare function isTimeoutError(args: WithError): args is WithError<TimeoutError>;

export { Json }

export declare type JsonApiRequestError = ApiRequestError | InvalidDataError;

export declare type JsonObject = Record<string, Json>;

export declare function keepFresh<Params>(query: Query<Params, any, any, any>, config: {
    automatically: true;
    enabled?: Store<boolean>;
}): void;

export declare function keepFresh<Params>(query: Query<Params, any, any, any>, config: {
    triggers: Array<Event_2<any> | TriggerProtocol>;
    enabled?: Store<boolean>;
}): void;

export declare function keepFresh<Params>(query: Query<Params, any, any, any>, config: {
    automatically: true;
    triggers: Array<Event_2<any> | TriggerProtocol>;
    enabled?: Store<boolean>;
}): void;

export declare function linearDelay(base: number, opts?: DelayOptions_2): ({ attempt }: RetryMeta) => number;

export declare function localStorageCache(config?: CacheAdapterOptions & SerializeConfig): CacheAdapter;

export declare const Meta: unique symbol;

declare type Millisecond = `${number}${MillisecondUnit}`;

declare type MillisecondUnit = 'ms' | 'milli' | 'millisecond' | 'milliseconds';

declare type Min = `${number}${MinUnit}`;

declare type MinUnit = 'm' | 'min' | 'mins' | 'minute' | 'minutes';

export declare interface Mutation<Params, Data, Error> extends RemoteOperation<Params, Data, Error, {}> {
    '@@unitShape': () => {
        start: EventCallable<Params>;
        pending: Store<boolean>;
    };
}

declare class Mutex {
    private _resolve;
    private _promise;
    constructor(locked?: boolean);
    get isLocked(): boolean;
    acquire(): void;
    waitForUnlock(): Promise<void>;
    release(): void;
}

declare const NETWORK = "NETWORK";

export declare interface NetworkError extends FarfetchedError<typeof NETWORK> {
    reason: string | null;
    cause?: unknown;
}

export declare function networkError(config: {
    reason: string | null;
    cause?: unknown;
}): NetworkError;

export declare const NodeLinksSumbol: unique symbol;

export declare const NodeMetaSumbol: unique symbol;

declare type NonExtendable = {
    [K in string]: never;
};

export declare function normalizeSourced<Data, Result, Source>(config: {
    field: SourcedField<Data, Result, Source>;
}): Store<(params: Data) => Result>;

export declare function normalizeSourced<Data, Result, Source>(config: {
    field: SourcedField<Data, Result, Source>;
}): Store<(params: Data) => Result>;

/**
 * Binds a callback to be called when the Operation is aborted
 *
 * @param callback Callback to be called when the Operation is aborted
 */
export declare function onAbort(callback: () => void): void;

/**
 * Copy-paste from Effector's sources
 */
declare type OptionalParams<Args extends any[]> = Args['length'] extends 0 ? void : 0 | 1 extends Args['length'] ? /**
* Applying `infer` to a variadic arguments here we'll get `Args` of
* shape `[T]` or `[T?]`, where T(?) is a type of handler `params`.
* In case T is optional we get `T | undefined` back from `Args[0]`.
* We lose information about argument's optionality, but we can make it
* optional again by appending `void` type, so the result type will be
* `T | undefined | void`.
*
* The disadvantage of this method is that we can't restore optonality
* in case of `params?: any` because in a union `any` type absorbs any
* other type (`any | undefined | void` becomes just `any`). And we
* have similar situation also with the `unknown` type.
*/ Args[0] | void : Args[0];

export declare interface ParamsDeclaration<T> {
    watch(cb: (payloaad: T) => void): Subscription;
}

declare type Performer = RemoteOperation<void, any, any, any> | Effect<void, any, any> | {
    start: EventCallable<void>;
    end: Event_2<any>;
};

declare const PREPARATION = "PREPARATION";

export declare interface PreparationError extends FarfetchedError<typeof PREPARATION> {
    response: string;
    reason: string | null;
}

export declare function preparationError(config: {
    response: string;
    reason: string | null;
}): PreparationError;

export declare interface Query<Params, Data, Error, InitialData = null> extends RemoteOperation<Params, Data, Error, QueryMeta<Data, InitialData>, QueryExtraLowLevelAPI> {
    /**
     * Start fetching data if it is absent or stale.
     */
    refresh: EventCallable<Params>;
    /**
     * The reactive value of the latest received data.
     *
     * If there was an error during fetching or there has not been a request yet, the store will be `null`.
     */
    $data: Store<Data | InitialData>;
    /**
     * The reactive value of the data retrieval error.
     *
     * If the data was successfully fetched or there is no request yet, the store will be `null`.
     */
    $error: Store<Error | null>;
    /**
     * Is data stale?
     */
    $stale: StoreWritable<boolean>;
    '@@unitShape': () => {
        data: Store<Data | InitialData>;
        error: Store<Error | null>;
        stale: Store<boolean>;
        pending: Store<boolean>;
        start: EventCallable<Params>;
    };
}

declare type QueryExtraLowLevelAPI = {
    refreshSkipDueToFreshness: Event_2<void>;
};

declare type QueryInitialData<Q extends Query<any, any, any, any>> = Q['__']['meta']['initialData'];

declare interface QueryMeta<Data, InitialData> {
    /**
     * This field is used to determine how to serialize data in various cases:
     * - transfer state from server to client during SSR
     * - save state to persistent storage during caching
     */
    serialize: Serialize<Data | InitialData>;
    initialData: InitialData;
    sid: string | null;
}

declare type QueryState<Q extends Query<any, any, any, any>> = {
    result: RemoteOperationResult<Q>;
    params: RemoteOperationParams<Q>;
} | {
    error: RemoteOperationError<Q>;
    params: RemoteOperationParams<Q>;
} | (QueryInitialData<Q> extends null ? null : {
    result: QueryInitialData<Q>;
});

declare type Refetch<Q extends Query<any, any, any, any>> = boolean | {
    params: RemoteOperationParams<Q>;
};

declare interface RemoteOperation<Params, Data, Error, Meta, ExtraLowLevelAPI = {}> {
    /**
     * Reactive current request status
     *
     * + `initial` — the data has never been fetched yet
     * + 'pending' — the data is being fetched right now
     * + 'done' — the data has been successfully fetched
     * + 'fail' — an error occurred while fetching data
     */
    $status: Store<FetchingStatus>;
    /** Is fetching started? */
    $idle: Store<boolean>;
    /** Is fetching in progress right now? */
    $pending: Store<boolean>;
    /** Is fetching failed? */
    $failed: Store<boolean>;
    /** Is fetching succeeded? */
    $succeeded: Store<boolean>;
    /** Is fetching finished? */
    $finished: Store<boolean>;
    /**
     * Is operation enabled?
     *
     * + false — any `start` call will be ignored, event done.skip will be fired immediately
     * + true — query will be executed after any `start` call
     */
    $enabled: Store<boolean>;
    /** Event to trigger operation */
    start: EventCallable<Params>;
    /** Event to reset the whole state of the operation */
    reset: EventCallable<void>;
    /** Event that trigered after operation started */
    started: Event_2<{
        params: Params;
        meta: ExecutionMeta;
    }>;
    aborted: Event_2<{
        params: Params;
        meta: ExecutionMeta;
    }>;
    /** Set of events that represent end of query */
    finished: {
        /** Query was successfully ended, data will be passed as a payload */
        success: Event_2<{
            params: Params;
            result: Data;
            meta: ExecutionMeta;
        }>;
        /** Query was failed, error will be passed as a payload */
        failure: Event_2<{
            params: Params;
            error: Error;
            meta: ExecutionMeta;
        }>;
        /** Query execution was skipped due to `enabled` field in config */
        skip: Event_2<{
            params: Params;
            meta: ExecutionMeta;
        }>;
        /** Query was ended, it merges `success`, `error` and `skip` */
        finally: Event_2<{
            params: Params;
            meta: ExecutionMeta;
        } & ({
            status: 'done';
            result: Data;
        } | {
            status: 'fail';
            error: Error;
        } | {
            status: 'skip';
        })>;
    };
    /**
     * DO NOT USE THIS FIELD IN PRODUCTION
     *
     * It is internal operator details which is useful for testing.
     */
    __: {
        /**
         * Internal effect, which executes to retrieve data.
         *
         * It must not be used in production. Please use it only for test purposes.
         *
         * @example
         *
         * import { locationQuery } from './location';
         *
         * test('some test', async () => {
         *   const scope = fork({
         *     handlers: [[locationQuery.__.executeFx, vi.fn()]]
         *   });
         *
         *   //...test code
         * })
         */
        executeFx: Effect<any, any, any>;
        /**
         * Meta information about operation and its configuration.
         */
        meta: Meta & DefaultMeta;
        /**
         * Distinguish different kinds of operations
         */
        kind: unknown;
        $latestParams: Store<Params | undefined>;
        /**
         * Low-level API, it can be changed anytime without any notice!
         */
        lowLevelAPI: {
            dataSources: Array<DataSource<Params>>;
            dataSourceRetrieverFx: Effect<{
                params: Params;
                meta: ExecutionMeta;
            }, {
                result: unknown;
                stale: boolean;
            }, any>;
            sourced: SourcedField<Params, unknown, unknown>[];
            paramsAreMeaningless: boolean;
            revalidate: EventCallable<{
                params: Params;
                refresh: boolean;
            }>;
            pushData: EventCallable<Data>;
            pushError: EventCallable<Error>;
            startWithMeta: EventCallable<{
                params: Params;
                meta: ExecutionMeta;
            }>;
            callObjectCreated: Event_2<CallObject>;
            failedIgnoreSuppression: Event_2<{
                params: Params;
                error: Error;
                meta: ExecutionMeta;
            }>;
            failedBeforeMap: EventCallable<{
                params: Params;
                error: Error;
                meta: ExecutionMeta;
            }>;
        } & ExtraLowLevelAPI;
    };
}

export declare type RemoteOperationError<Q extends RemoteOperation<any, any, any, any>> = EventPayload<Q['finished']['failure']>['error'];

export declare type RemoteOperationParams<Q extends RemoteOperation<any, any, any, any>> = EventPayload<Q['start']>;

export declare type RemoteOperationResult<Q extends RemoteOperation<any, any, any, any>> = EventPayload<Q['finished']['success']>['result'];

declare type RequestConfig<Params, BodySource, QuerySource, HeadersSource, UrlSource> = {
    url: SourcedField<Params, string, UrlSource>;
    credentials?: RequestCredentials;
    fetch?: StaticOrReactive<FetchOptions>;
    query?: SourcedField<Params, FetchApiRecord, QuerySource> | SourcedField<Params, string, QuerySource>;
    headers?: SourcedField<Params, FetchApiRecord, HeadersSource>;
} & ({
    method: 'GET' | 'HEAD';
} | {
    method: Exclude<HttpMethod, 'GET' | 'HEAD'>;
    body?: SourcedField<Params, Json, BodySource>;
});

declare type RequestConfig_2<Params, BodySource, QuerySource, HeadersSource, UrlSource> = {
    url: SourcedField<Params, string, UrlSource>;
    credentials?: RequestCredentials;
    fetch?: StaticOrReactive<FetchOptions>;
    query?: SourcedField<Params, FetchApiRecord, QuerySource> | SourcedField<Params, string, QuerySource>;
    headers?: SourcedField<Params, FetchApiRecord, HeadersSource>;
} & ({
    method: 'GET' | 'HEAD';
} | {
    method: Exclude<HttpMethod, 'GET' | 'HEAD'>;
    body?: SourcedField<Params, Json, BodySource>;
});

export declare const Result: unique symbol;

export declare function retry<Q extends RemoteOperation<any, any, any, any>, DelaySource = unknown, FilterSource = unknown, MapParamsSource = unknown>(operation: Q, { times, delay: timeout, filter, mapParams, ...params }: RetryConfig<Q, DelaySource, FilterSource, MapParamsSource>): void;

declare type RetryConfig<Q extends RemoteOperation<any, any, any, any>, DelaySource = unknown, FilterSource = unknown, MapParamsSource = unknown> = {
    times: StaticOrReactive<number>;
    delay: SourcedField<RetryMeta, Time, DelaySource>;
    filter?: SourcedField<FailInfo<Q>, boolean, FilterSource>;
    mapParams?: DynamicallySourcedField<FailInfo<Q> & {
        meta: RetryMeta;
    }, RemoteOperationParams<Q>, MapParamsSource>;
    otherwise?: EventCallable<FailInfo<Q>>;
    supressIntermediateErrors?: boolean;
};

declare interface RetryMeta {
    attempt: number;
}

declare type RuleResult<Q extends Query<any, any, any, any>> = {
    result: RemoteOperationResult<Q> | QueryInitialData<Q>;
    refetch?: Refetch<Q>;
} | {
    error: RemoteOperationError<Q>;
    refetch?: Refetch<Q>;
};

declare type Sec = `${number}${SecUnit}`;

declare type SecUnit = 's' | 'sec' | 'secs' | 'second' | 'seconds';

declare type Serialize<Data> = NonNullable<Parameters<typeof createStore<Data>>[1]>['serialize'];

declare type SerializeConfig = {
    serialize?: {
        read: (value: Json) => unknown;
        write: (value: unknown) => Json;
    };
};

export declare function sessionStorageCache(config?: CacheAdapterOptions & SerializeConfig): CacheAdapter;

declare interface SharedMutationFactoryConfig {
    name?: string;
    enabled?: StaticOrReactive<boolean>;
}

declare interface SharedQueryFactoryConfig<Data, Initial = Data> {
    name?: string;
    enabled?: StaticOrReactive<boolean>;
    serialize?: Serialize<Data | Initial>;
}

export declare type SourcedField<Data, Result, Source> = Result | Store<Result> | Callback<Data, Result> | CallbackWithSource<Data, Result, Source>;

declare type StaticOrReactive<T> = T | Store<Exclude<T, undefined>>;

declare type Time = `${Hour} ${Min} ${Sec}` | `${Hour} ${Min}` | `${Min} ${Sec}` | `${Hour}` | `${Min}` | `${Sec}` | `${Hour} ${Min} ${Sec} ${Millisecond}` | `${Hour} ${Min} ${Millisecond}` | `${Min} ${Sec} ${Millisecond}` | `${Hour} ${Millisecond}` | `${Min} ${Millisecond}` | `${Sec} ${Millisecond}` | `${Millisecond}` | number;

declare const TIMEOUT = "TIMEOUT";

/**
 *
 * Applies timeout to the operation - if operation is not finished in specified time, it will be aborted
 *
 * @param operation - Any remote operation, like Query or Mutation
 * @param config - Timeout config
 * @param config.after - Time after which operation will be aborted, can be human-readable string (like "100ms") or number in milliseconds, or effector's `Store` with any of these types
 */
export declare function timeout<Q extends RemoteOperation<any, any, any, any>>(operation: Q, config: {
    after: StaticOrReactive<Time>;
}): void;

export declare interface TimeoutError extends FarfetchedError<typeof TIMEOUT> {
    timeout: number;
}

export declare function timeoutError(config: {
    timeout: number;
}): TimeoutError;

declare type TriggerProtocol = {
    '@@trigger': () => {
        setup: EventCallable<void>;
        teardown: EventCallable<void>;
        fired: Event_2<unknown> | Event_2<void>;
    };
};

export declare const unknownContract: Contract<unknown, unknown>;

export declare function update<Q extends Query<any, any, any, any>, M extends Mutation<any, any, any>, BySuccessSource = void, ByFailureSource = void>(query: Q, { on: mutation, by: rules, }: {
    on: M;
    by: {
        success: DynamicallySourcedField<{
            query: QueryState<Q>;
            mutation: {
                result: RemoteOperationResult<M>;
                params: RemoteOperationParams<M>;
            };
        }, RuleResult<Q>, BySuccessSource>;
        failure?: DynamicallySourcedField<{
            query: QueryState<Q>;
            mutation: {
                error: RemoteOperationError<M>;
                params: RemoteOperationParams<M>;
            };
        }, RuleResult<Q>, ByFailureSource>;
    };
}): void;

export declare type ValidationResult = boolean | string | string[];

export declare type Validator<Data, Params, ValidationSource> = DynamicallySourcedField<{
    result: Data;
    params: Params;
}, ValidationResult, ValidationSource>;

export declare function voidCache(): CacheAdapter;

declare type WithError<T = any, P = Record<string, unknown>> = P & {
    error: T;
};

export { }