import type { BackupCodeRepository, FederatedAccount, FederatedAccountRepository, FullAuthUser, Invitation, InvitationRepository, NotificationPreference, NotificationPreferenceRepository, NotificationRecord, NotificationRepository, Passkey, PasskeyRepository, PushSubscriptionData, PushSubscriptionRepository, RefreshTokenRecord, RefreshTokenRepository, Repositories, UserRepository } from './types.js';
interface StoredInvitation extends Invitation {
    invitedById: string;
    /** Projected away by the contract-facing reads — the hash never leaves here. */
    tokenHash: string;
}
interface StoredPushSubscription extends PushSubscriptionData {
    userId: string;
}
interface StoredPreference extends NotificationPreference {
    userId: string;
}
interface StoredBackupCode {
    userId: string;
    codeHash: string;
    usedAt: Date | null;
}
/** Every table of the adapter, one row map (plus its unique indexes) each. */
interface Tables<R extends string> {
    users: Map<string, FullAuthUser<R>>;
    usersByEmail: Map<string, string>;
    invitations: Map<string, StoredInvitation>;
    invitationsByEmail: Map<string, string>;
    invitationsByTokenHash: Map<string, string>;
    notifications: Map<string, NotificationRecord>;
    pushSubscriptions: Map<string, StoredPushSubscription>;
    notificationPreferences: Map<string, StoredPreference>;
    passkeys: Map<string, Passkey>;
    refreshTokens: Map<string, RefreshTokenRecord>;
    refreshTokensByHash: Map<string, string>;
    backupCodes: StoredBackupCode[];
    federatedAccounts: Map<string, FederatedAccount>;
}
declare const TABLES: unique symbol;
/**
 * The database behind the in-memory adapter — one handle, every table.
 *
 * Every `createInMemory*Repository(store)` factory is a view on the store it
 * is given: repositories built on the same store share rows, and
 * `user.delete` erases a user's dependents from every table of that store.
 * Rows on a different store are as far away as another database. The handle
 * exposes no state of its own; `createInMemoryStore()` is the only way to get
 * one.
 */
export interface InMemoryStore<R extends string = string> {
    readonly [TABLES]: Tables<R>;
}
export declare function createInMemoryStore<R extends string = string>(): InMemoryStore<R>;
/**
 * In-memory implementation of the full {@link Repositories} contract: a fresh
 * {@link createInMemoryStore} with every repository built on it.
 *
 * **Dev / test only.** State lives in plain `Map`s on the heap — it is wiped on
 * restart and not shared across processes or instances. Use it for the
 * five-minute quickstart, local development, and as the fixture every adapter
 * conformance run executes against. **Never** ship it to production; pass a
 * persistent adapter (`createPrismaRepos`, or your own) instead.
 *
 * ### Why this is a faithful reference (not just a stub)
 *
 * The atomicity the interface demands of a real database — single-use token
 * claims, compare-and-set rotation/counter bumps, lossless increments — is
 * reproduced here the only way single-threaded JavaScript can: every claim
 * method performs its **read and conditional write with no `await` in
 * between**, so two concurrent calls can never interleave through the decision.
 * That is exactly the property the exported conformance suite asserts, which is
 * why this adapter passes it. An implementation that `await`ed mid-claim would
 * fail the same suite — see `conformance.ts`.
 */
export declare function createInMemoryRepos<R extends string = string>(): Repositories<R>;
export declare function createInMemoryUserRepository<R extends string = string>(store: InMemoryStore<R>): UserRepository<R>;
export declare function createInMemoryInvitationRepository<R extends string = string>(store: InMemoryStore<R>): InvitationRepository;
export declare function createInMemoryNotificationRepository<R extends string = string>(store: InMemoryStore<R>): NotificationRepository;
export declare function createInMemoryPushSubscriptionRepository<R extends string = string>(store: InMemoryStore<R>): PushSubscriptionRepository;
export declare function createInMemoryNotificationPreferenceRepository<R extends string = string>(store: InMemoryStore<R>): NotificationPreferenceRepository;
export declare function createInMemoryPasskeyRepository<R extends string = string>(store: InMemoryStore<R>): PasskeyRepository;
/**
 * In-memory `RefreshTokenRepository`. Suitable only for single-process
 * deployments and tests — production consumers should pass a persistent
 * implementation (Prisma, Redis, etc.) via `repos.refreshToken`.
 */
export declare function createInMemoryRefreshTokenRepository<R extends string = string>(store: InMemoryStore<R>): RefreshTokenRepository;
export declare function createInMemoryBackupCodeRepository<R extends string = string>(store: InMemoryStore<R>): BackupCodeRepository;
export declare function createInMemoryFederatedAccountRepository<R extends string = string>(store: InMemoryStore<R>): FederatedAccountRepository;
export {};