import type { StorageChangeOperation, StorageChangeSource, StorageKeyChangeEvent } from "./storage-events";
import { StorageScope } from "./Storage.types";
import type { AccessControl, BiometricLevel } from "./Storage.types";
export type Validator<T> = (value: unknown) => value is T;
export type ExpirationConfig = {
    ttlMs: number;
};
export type StorageVersion = string;
export type VersionedValue<T> = {
    value: T;
    version: StorageVersion;
};
export type StorageMetricsEvent = {
    operation: string;
    scope: StorageScope;
    durationMs: number;
    keysCount: number;
};
export type StorageMetricsObserver = (event: StorageMetricsEvent) => void;
export type StorageEventObserverOptions = {
    redactSecureValues?: boolean;
};
export type StorageExportOptions = {
    includeSecureValues?: boolean;
};
export type StorageMetricSummary = {
    count: number;
    totalDurationMs: number;
    avgDurationMs: number;
    maxDurationMs: number;
};
export type StorageSelectorListener<TSelected> = (value: TSelected, previousValue: TSelected) => void;
export type StorageSelectorSubscribeOptions<TSelected> = {
    isEqual?: (previousValue: TSelected, nextValue: TSelected) => boolean;
    fireImmediately?: boolean;
};
export type MigrationContext = {
    scope: StorageScope;
    getRaw: (key: string) => string | undefined;
    setRaw: (key: string, value: string) => void;
    removeRaw: (key: string) => void;
};
export type Migration = (context: MigrationContext) => void;
export type KeyListenerRegistry = Map<string, Set<() => void>>;
export type RawBatchPathItem = {
    _hasValidation?: boolean;
    _hasExpiration?: boolean;
    _hasRenameFrom?: boolean;
    _isBiometric?: boolean;
    _biometricLevel?: BiometricLevel;
    _secureAccessControl?: AccessControl;
};
export type RollbackRecord = {
    kind: "memory";
    value: unknown;
    expiresAt?: number;
} | {
    kind: "raw";
    value: string | undefined;
    accessControl?: AccessControl;
} | {
    kind: "biometric";
    value: string | undefined;
    level: BiometricLevel;
};
export type StorageCompositeError = Error & {
    readonly cause: unknown;
    readonly errors: readonly unknown[];
    readonly code: "storage_compensation_failed";
};
export type StorageCompensationError = StorageCompositeError;
export declare function createStorageCompositeError(operation: string, primary: unknown, contexts: readonly {
    label: string;
    error: unknown;
}[]): StorageCompositeError;
export declare function normalizeStorageError(error: unknown): unknown;
export declare function isUpdater<T>(valueOrFn: T | ((prev: T) => T)): valueOrFn is (prev: T) => T;
export declare function typedKeys<K extends string, V>(record: Record<K, V>): K[];
export declare function assertEnumInteger(value: number, min: number, max: number, label: string): void;
export declare function assertAccessControlLevel(level: number): void;
export declare function assertBiometricLevel(level: number): void;
export type NonMemoryScope = StorageScope.Disk | StorageScope.Secure;
export type PendingDiskWrite = {
    key: string;
    value: string | undefined;
    generation: number;
};
export type PendingSecureWrite = {
    key: string;
    value: string | undefined;
    accessControl?: AccessControl;
    generation: number;
};
export declare const runMicrotask: typeof queueMicrotask;
export declare const now: () => number;
export declare function notifyKeyListeners(registry: KeyListenerRegistry, key: string): void;
export declare function notifyAllListeners(registry: KeyListenerRegistry): void;
export declare function createKeyChange(scope: StorageScope, key: string, oldValue: string | undefined, newValue: string | undefined, operation: StorageChangeOperation, source: StorageChangeSource): StorageKeyChangeEvent;
export declare const SECURE_EVENT_REDACTED_VALUE = "[secure]";
export declare function redactSecureKeyChange(event: StorageKeyChangeEvent): StorageKeyChangeEvent;
export declare function canUseRawBatchPath(item: RawBatchPathItem): boolean;
export declare function canUseSecureRawBatchPath(item: RawBatchPathItem): boolean;
export declare function defaultSerialize<T>(value: T): string;
export declare function defaultDeserialize<T>(value: string): T;
export type SecureAuthStorageConfig<K extends string = string> = Record<K, {
    ttlMs?: number;
    biometric?: boolean;
    biometricLevel?: BiometricLevel;
    accessControl?: AccessControl;
    renameFrom?: string | readonly string[];
}>;
/**
 * @deprecated Use isStorageError(error, code) to distinguish temporary lock,
 * authentication, and invalidated-key recovery paths.
 */
export declare function isKeychainLockedError(err: unknown): boolean;
//# sourceMappingURL=shared.d.ts.map