import type { Adapter } from './adapter';
import type { AdapterWithContext } from './AdapterContext';
import type { AdapterRequestContext } from './AdapterRequestContext';
import type { BuildCachedSnapshot, BuildNetworkSnapshot, CachePolicy } from './CachePolicy';
import type { ProxyGraphNode } from './GraphNode';
import type { FetchResponse, NetworkAdapter, ResourceIngest, ResourceRequest, ResourceRequestContext } from './network';
import type { Luvio, WithContextOptions } from './Root';
import type { Selector } from './Select';
import type { AvailableSnapshot, DataSnapshot, ErrorSnapshot, PendingSnapshot, Snapshot, SnapshotRefresh } from './interfaces/Snapshot';
import type { DurableStoreKeyMetadataMap, CreateStoreMetadataParams, SnapshotCreate, SnapshotRebuild, SnapshotSubscriptionCallback, StoreEntry, StoreMetadata, Unsubscribe, WatchSubscriptionCallback, Store, TTLOverrideMap, GetNotifyChangeEntry } from './interfaces/Store';
import type { TTLStrategy } from './reader/resolve';
import type { LuvioAdapterEventObserver } from './events';
import type { KeyMetadata, NormalizedKeyMetadata, StoreQueryEvaluator } from './interfaces/queryability';
export declare class Environment {
    private networkAdapter;
    private store;
    private adapterContextMap;
    private networkCount;
    private storeQueryEvaluator;
    private typeQueryEvaluatorMap;
    private defaultCachePolicy;
    constructor(store: Store, networkAdapter: NetworkAdapter);
    setDefaultCachePolicy(cachePolicy: CachePolicy): void;
    /**
     * Returns a resolved promise of a FetchResponse for ok http status codes.
     * Returns a rejected promise of an ErrorResponse of type "fetchResponse" for non-ok http status codes.
     * Returns a rejected promise of an ErrorResponse of type "networkError" if server can't be reached
     *
     * @throws {ErrorResponse}
     */
    dispatchResourceRequest<T>(request: ResourceRequest, context: ResourceRequestContext, eventObservers?: LuvioAdapterEventObserver[]): Promise<FetchResponse<T>>;
    isErrorCacheable(errorSnapshot: ErrorSnapshot): boolean;
    /**
     * Returns a Promise that resolves once the given PendingSnapshot is available.
     */
    resolvePendingSnapshot<D, V = unknown>(snapshot: PendingSnapshot<D, V>): Promise<Snapshot<D, V>>;
    storeIngest<Response>(key: string | NormalizedKeyMetadata, ingest: ResourceIngest | null, response: Response, luvio: Luvio, storeOverride?: Store): void;
    storeIngestError(key: string | NormalizedKeyMetadata, errorSnapshot: ErrorSnapshot, storeMetadataParams?: CreateStoreMetadataParams, storeOverride?: Store): void;
    storePublish<Data>(key: string | NormalizedKeyMetadata, data: Data): void;
    storePut<Data>(key: string | NormalizedKeyMetadata, data: Data): void;
    storeRedirect(existingKey: string | NormalizedKeyMetadata, redirectKey: string): void;
    storeGetCanonicalKey(key: string | NormalizedKeyMetadata): string | NormalizedKeyMetadata;
    storeBroadcast(rebuildSnapshot: SnapshotRebuild<unknown, unknown>, snapshotAvailable: (snapshot: Snapshot<unknown, unknown>) => boolean): Promise<void>;
    storeSubscribe<D, V = unknown>(snapshot: Snapshot<D, V>, callback: SnapshotSubscriptionCallback<D, V>): Unsubscribe;
    storeWatch(prefix: string | Partial<NormalizedKeyMetadata>, callback: WatchSubscriptionCallback): Unsubscribe;
    storeLookup<D, V = unknown>(sel: Selector<V>, createSnapshot: SnapshotCreate<D, V>, refresh?: SnapshotRefresh<D>, ttlStrategy?: TTLStrategy): Snapshot<D, V>;
    storeCleanup(): void;
    storeEvict(key: string | NormalizedKeyMetadata): void;
    storeDealloc(key: string | NormalizedKeyMetadata): void;
    storeReset(): void;
    storeRetain(keys: string[] | NormalizedKeyMetadata[]): () => void;
    storeKeyExists(key: string | NormalizedKeyMetadata): boolean;
    snapshotAvailable(snapshot: Snapshot<unknown, unknown>): snapshot is AvailableSnapshot<unknown, unknown>;
    createSnapshot<D, V = unknown>(selector: Selector<V>, refresh?: SnapshotRefresh<D>, ttlStrategy?: TTLStrategy): Snapshot<D, V>;
    rebuildSnapshot<D, V = unknown>(snapshot: DataSnapshot<D, V>, onRebuild: (rebuilt: Snapshot<D, V>) => void): void;
    getNode<N, D = N>(key: string | NormalizedKeyMetadata, storeOverride?: Store): ProxyGraphNode<N, D>;
    wrapNormalizedGraphNode<N, D>(normalized: StoreEntry<N>, key: string | NormalizedKeyMetadata, storeOverride?: Store): ProxyGraphNode<N, D>;
    withContext<C, D>(adapter: AdapterWithContext<C, D>, options: WithContextOptions): (config: C, requestContext?: AdapterRequestContext) => ReturnType<Adapter<C, D>>;
    publishStoreMetadata(key: string | NormalizedKeyMetadata, storeMetadata: StoreMetadata): void;
    putStoreMetadata(key: string | NormalizedKeyMetadata, storeMetadata: StoreMetadata, adjustTTLOverride: boolean): void;
    storeSetTTLOverride(namespace: string, representationName: string, ttl: number): Promise<void>;
    storeGetTTLOverride(namespace: string, representationName: string): Promise<number | undefined>;
    storeGetTTLOverrides(): TTLOverrideMap;
    recomputeTTLOverrideExpirations(ttlNamespace: string, ttlRepresentationName: string): void;
    storeSetDefaultTTLOverride(ttl: number): Promise<void>;
    storeGetDefaultTTLOverride(): number | undefined;
    recomputeDefaultTTLOverrideExpirations(): void;
    storeBuildIngestionStagingStore(): Store;
    applyCachePolicy<C, D>(luvio: Luvio, adapterRequestContext: AdapterRequestContext, buildSnapshotContext: C, buildCachedSnapshot: BuildCachedSnapshot<C, D>, buildNetworkSnapshot: BuildNetworkSnapshot<C, D>): Snapshot<D> | Promise<Snapshot<D>>;
    handleSuccessResponse<IngestionReturnType>(ingestAndBroadcastFunc: () => Promise<Awaited<IngestionReturnType>>, _getResponseCacheKeysFunc: () => DurableStoreKeyMetadataMap): Promise<Awaited<IngestionReturnType>>;
    handleErrorResponse(ingestAndBroadcastFunc: () => Promise<ErrorSnapshot>): Promise<ErrorSnapshot>;
    /**
     * Gets store entries for notifyChange purposes.  Returns a Promise to
     * support environments that need to do async cache lookups.
     *
     * If not in the store then the cache key is not added to the returned set.
     */
    getNotifyChangeStoreEntries<T>(keys: string[] | NormalizedKeyMetadata[]): Promise<GetNotifyChangeEntry<T>[]>;
    notifyStoreUpdateAvailable(keys: string[] | NormalizedKeyMetadata[]): Promise<void>;
    registerStoreQueryEvaluator<T>(queryEvaluator: StoreQueryEvaluator<T>): void;
    getStoreQueryEvaluator<T>(): StoreQueryEvaluator<T> | undefined;
    registerTypeQueryEvaluator<T>(namespace: string, representationName: string, queryEvaluator: T): void;
    getTypeQueryEvaluator<T>(namespace: string, representationName: string): T | undefined;
    buildStructuredKey(namespace: string, representationName: string, idValues: KeyMetadata): NormalizedKeyMetadata;
    /**
     * Take a list of keys and marks them as stale to be refreshed.
     * Then will be refreshed with the provided refresh function.
     * If no refresh and makeConfig functions are provided it will refresh
     * time that record is trying to be fetched
     *
     * Example: one record from graphql needs to be refreshed and not
     * the entire graphql query
     *
     * @param keys
     * @param makeConfig
     * @param refresh
     * @returns
     */
    expirePossibleStaleRecords<Config, DataType>(keys: string[] | NormalizedKeyMetadata[], config?: Config, refresh?: Adapter<Config, DataType>): Promise<void>;
    refreshPossibleStaleRecords<Config, DataType>(config: Config, refresh: Adapter<Config, DataType>): Promise<void>;
}