import type { FetchResponse } from '../network';
import type { Selector } from '../Select';
import type { DataSnapshot, FetchErrorResponse } from './Snapshot';
import type { ErrorSnapshot, Snapshot, SnapshotRefresh } from './Snapshot';
import type { TTLStrategy } from '../reader/resolve';
import type { LuvioStoreEventObserver } from '../events';
import type { KeyMetadata, NormalizedKeyMetadata } from '../interfaces/queryability';
import type { StoreKeyMap } from '../store/StoreKeyMap';
export interface StringKeyStore {
    eventObservers: LuvioStoreEventObserver[];
    addStoreEventObserver(storeEventObserver: LuvioStoreEventObserver): Unsubscribe;
    put<T>(recordId: string, record: StoreEntry<T>): void;
    publish<T>(recordId: string, record: StoreEntry<T>): void;
    getCanonicalRecordId(recordId: string): string;
    redirect(key: string, canonicalKey: string): void;
    broadcast(rebuildSnapshot: SnapshotRebuild<unknown, unknown>, snapshotAvailable: (snapshot: Snapshot<unknown, unknown>) => boolean): Promise<void>;
    broadcastNonCachedSnapshot(recordId: string, errorSnapshot: ErrorSnapshot): void;
    lookup<D, V = unknown>(selector: Selector<V>, createSnapshot: SnapshotCreate<D, V>, refresh?: SnapshotRefresh<D>, ttlStrategy?: TTLStrategy): Snapshot<D, V>;
    subscribe<D, V = unknown>(snapshot: Snapshot<D, V>, callback: SnapshotSubscriptionCallback<D, V>): Unsubscribe;
    updateAvailable(keys: string[]): Promise<void>;
    retain(keys: string[]): Release;
    watch(prefix: string, callback: WatchSubscriptionCallback): Unsubscribe;
    cleanup(): void;
    evict(key: string): void;
    dealloc(key: string): void;
    publishMetadata(key: string, storeMetadata: StoreMetadata): void;
    setTTLOverride(namespace: string, representationName: string, ttl: number): void;
    getTTLOverrides(): TTLOverrideMap;
    setDefaultTTLOverride(ttl: number): void;
    getDefaultTTLOverride(): number | undefined;
    reset(): void;
    getRedirectLineage(key: string): string[];
    readEntry<T>(key: string): StoreEntry<T>;
    readMetadata(key: string): StoreMetadata;
    readMetadataWhere(query: {
        namespace?: string;
        representationName?: string;
        ttlOverride?: number | undefined;
    }): {
        metadata: StoreMetadata;
        key: string;
    }[];
    getNumEntries(): number;
    /**
     * Some environments might ingest into a "staging" store, this method builds
     * a new Store from the current store made for staging.  Staging and base stores
     * should share ttl overrides and redirect keys (which are both read during
     * ingestion flows) so this method should ensure that.
     */
    buildIngestionStagingStore(): StringKeyStore;
    /**
     * Serializing then deserializing a Luvio store's data+metadata enables SSR usecases.
     */
    serialize(): SerializedStoreShape;
    /**
     * Checks to see if a given key exists in the store
     * @param key
     */
    keyExistsInStore(key: string): boolean;
    expirePossibleStaleRecords(keys: string[]): void;
}
export interface Store {
    eventObservers: LuvioStoreEventObserver[];
    addStoreEventObserver(storeEventObserver: LuvioStoreEventObserver): Unsubscribe;
    publish<T>(recordId: string | NormalizedKeyMetadata, record: StoreEntry<T>): void;
    put<T>(recordId: string | NormalizedKeyMetadata, record: StoreEntry<T>): void;
    getCanonicalRecordId<KeyType extends string | NormalizedKeyMetadata>(recordId: KeyType): KeyType extends string ? string : NormalizedKeyMetadata;
    redirect(key: string | NormalizedKeyMetadata, canonicalKey: string | NormalizedKeyMetadata): void;
    broadcast(rebuildSnapshot: SnapshotRebuild<unknown, unknown>, snapshotAvailable: (snapshot: Snapshot<unknown, unknown>) => boolean): Promise<void>;
    broadcastNonCachedSnapshot(recordId: string | NormalizedKeyMetadata, errorSnapshot: ErrorSnapshot): void;
    lookup<D, V = unknown>(selector: Selector<V>, createSnapshot: SnapshotCreate<D, V>, refresh?: SnapshotRefresh<D>, ttlStrategy?: TTLStrategy): Snapshot<D, V>;
    subscribe<D, V = unknown>(snapshot: Snapshot<D, V>, callback: SnapshotSubscriptionCallback<D, V>): Unsubscribe;
    updateAvailable(keys: string[] | NormalizedKeyMetadata[]): Promise<void>;
    retain(keys: string[] | NormalizedKeyMetadata[]): Release;
    watch(partialKey: string | Partial<NormalizedKeyMetadata>, callback: WatchSubscriptionCallback): Unsubscribe;
    cleanup(): void;
    evict(key: string | NormalizedKeyMetadata): void;
    dealloc(key: string | NormalizedKeyMetadata): void;
    publishMetadata(key: string | NormalizedKeyMetadata, storeMetadata: StoreMetadata): void;
    putMetadata(key: string | NormalizedKeyMetadata, storeMetadata: StoreMetadata, adjustTTLOverride: boolean): void;
    setTTLOverride(namespace: string, representationName: string, ttl: number): void;
    getTTLOverride(namespace: string, representationName: string): number | undefined;
    getTTLOverrides(): StoreKeyMap<NormalizedKeyMetadata, number> | TTLOverrideMap;
    setDefaultTTLOverride(ttl: number): void;
    getDefaultTTLOverride(): number | undefined;
    reset(): void;
    getRedirectLineage(key: string | NormalizedKeyMetadata): string[] | NormalizedKeyMetadata[];
    readEntry<T>(key: string | NormalizedKeyMetadata): StoreEntry<T>;
    readMetadata(key: string | NormalizedKeyMetadata): StoreMetadata | undefined;
    readMetadataWhere(query: {
        namespace?: string;
        representationName?: string;
        ttlOverride?: number | undefined;
    }): {
        metadata: StoreMetadata;
        key: string | NormalizedKeyMetadata;
    }[];
    getNumEntries(): number;
    buildStructuredKey(namespace: string, representationName: string, idValues: KeyMetadata): NormalizedKeyMetadata;
    buildIngestionStagingStore(): Store;
    markVisited(canonicalKey: string | NormalizedKeyMetadata): void;
    /**
     * Checks to see if a given key exists in the store
     * @param key
     */
    keyExistsInStore(key: string | NormalizedKeyMetadata): boolean;
    expirePossibleStaleRecords(keys: string[] | NormalizedKeyMetadata[]): void;
}
export interface RecordSource {
    [key: string]: any;
}
export declare enum StoreErrorStatus {
    RESOURCE_NOT_FOUND = 404
}
export declare enum StoreRecordType {
    Error = "error"
}
export interface StoreRecordError {
    __type: StoreRecordType.Error;
    status: StoreErrorStatus;
    error: FetchResponse<unknown>;
}
export type StoreEntry<D> = StoreRecordError | null | D;
export type RedirectMap = Record<string, string>;
export type SnapshotRebuild<D, V = unknown> = (snapshot: DataSnapshot<D, V>, onRebuild: (rebuilt: Snapshot<D, V>) => void) => void;
export type SnapshotCreate<D, V = unknown> = (selector: Selector<V>, refresh?: SnapshotRefresh<D>, ttlStrategy?: TTLStrategy) => Snapshot<D, V>;
export type SnapshotSubscriptionCallback<D, V = unknown> = (data: Snapshot<D, V>) => void;
export interface WatchCallbackEntry {
    id: string;
    inserted: boolean;
}
export type WatchSubscriptionCallback = (entries: WatchCallbackEntry[]) => void;
export type IntegrityInfo = {
    [integrity: string]: {
        existingRecord: string | number | null;
        incomingRecord: string | number | null;
    };
};
export interface CreateStoreMetadataParams {
    namespace: string;
    representationName: string;
    ttl: number;
    version: string;
    integrityInfo?: IntegrityInfo;
    ingestionTimestamp?: number;
}
export interface StoreMetadata {
    expirationTimestamp: number;
    namespace: string;
    representationName: string;
    ingestionTimestamp: number;
    version: string;
}
export type StoreMetadataMap = Record<string, StoreMetadata>;
export type TTLOverrideMap = Record<string, number>;
export type publishMetadata = (key: string, metadata: StoreMetadata) => void;
export interface StoreLink<S = unknown> {
    __ref?: string;
    pending?: true;
    isMissing?: true;
    data?: S;
}
export type Unsubscribe = () => void;
export declare enum StoreLinkStateValues {
    NotPresent = 0,
    RefNotPresent = 1,
    RefPresent = 2,
    Null = 3,
    Missing = 4,
    Pending = 5
}
export interface StoreLinkStateRefPresent {
    state: StoreLinkStateValues.RefPresent;
    key: string;
}
interface StoreLinkStateNotPresent {
    state: StoreLinkStateValues.NotPresent;
}
interface StoreLinkStateRefNotPresent {
    state: StoreLinkStateValues.RefNotPresent;
}
interface StoreLinkStateNull {
    state: StoreLinkStateValues.Null;
}
interface StoreLinkStateMissing {
    state: StoreLinkStateValues.Missing;
}
interface StoreLinkStatePending {
    state: StoreLinkStateValues.Pending;
}
export type StoreLinkState = StoreLinkStateRefPresent | StoreLinkStateNotPresent | StoreLinkStateNull | StoreLinkStateMissing | StoreLinkStatePending | StoreLinkStateRefNotPresent;
export type Release = () => void;
export declare enum StoreResolveResultState {
    Found = 0,
    Error = 1,
    Null = 2,
    NotPresent = 3,
    Stale = 4
}
export interface StoreResolveResultFound<D> {
    state: StoreResolveResultState.Found;
    value: D;
    version: string | undefined;
    redirects: string[] | NormalizedKeyMetadata[];
    resolvedKey: string | NormalizedKeyMetadata;
}
interface StoreResolveResultError {
    state: StoreResolveResultState.Error;
    value: FetchErrorResponse;
    redirects: string[] | NormalizedKeyMetadata[];
    resolvedKey: string | NormalizedKeyMetadata;
    version: string | undefined;
}
interface StoreResolveResultNotPresent {
    state: StoreResolveResultState.NotPresent;
    redirects: string[] | NormalizedKeyMetadata[];
    resolvedKey: string | NormalizedKeyMetadata;
}
export interface StoreResolveResultStale {
    state: StoreResolveResultState.Stale;
    value: any;
    version: string | undefined;
    redirects: string[] | NormalizedKeyMetadata[];
    resolvedKey: string | NormalizedKeyMetadata;
}
export type StoreResolveResult<T> = StoreResolveResultFound<T> | StoreResolveResultError | StoreResolveResultNotPresent | StoreResolveResultStale;
type DurableStoreKeyMetadata = {
    namespace: string;
    representationName: string;
    mergeable: boolean;
};
export type DurableStoreKeyMetadataMap = StoreKeyMap<string | NormalizedKeyMetadata, DurableStoreKeyMetadata>;
/**
 * Individual shape for GetNotifyChangeEntries method.
 * Temporary "expand" type: Remove string union type as part of W-12501058
 */
export type GetNotifyChangeEntry<T> = {
    key: string | NormalizedKeyMetadata;
    record: T;
};
export type SerializedStoreShape = {
    luvioStoreData: any;
};
export type SerializedStoreDataInternal = {
    data: RecordSource;
    metadata: Record<string, StoreMetadata>;
    version: string;
};
export {};