import { I as ICreditRepository, d as CreditBalanceUpdate, T as TierUpdateInput, a as CreateReservationInput, b as CreateTransactionInput, c as CreateUsageLogInput, U as UsageLogQuery, C as CreateJournalEntryInput, J as JournalEntryQuery } from '../types-fW2JNmmr.js';
export { e as CreditRepositoryFactory, t as toClientUserCredits } from '../types-fW2JNmmr.js';
import { b as PortableUserCredits, S as SubscriptionTier, c as PortableReservation, R as ReservationStatus, P as PortableTransaction, d as PortableUsageLog, f as PortableJournalEntry, M as MonthlyResetResult, e as SubscriptionExpiryResult } from '../types-DgQtamEe.js';

/**
 * Shared utilities for credit repository implementations
 *
 * These are pure functions with no server-only dependencies,
 * making them safe to use in any repository implementation.
 */
/**
 * Generate a unique ID
 * Uses timestamp + random string for uniqueness
 */
declare function generateId(): string;
/**
 * Convert date-like value to Date object
 * Handles: Date, string, Firestore Timestamp
 */
declare function toDate(value: Date | string | unknown): Date;
/**
 * Get the first day of next month
 * Used for calculating monthly reset dates
 */
declare function getNextMonthlyReset(from?: Date): Date;

/**
 * In-Memory Credit Repository Implementation
 *
 * A database-agnostic implementation of ICreditRepository for testing and prototyping.
 * All data is stored in memory and lost when the process restarts.
 *
 * Usage:
 * - Unit tests without database dependency
 * - Local development and prototyping
 * - Reference implementation for custom repositories
 */

/**
 * In-Memory implementation of ICreditRepository
 *
 * Implements all repository methods using Map-based storage.
 * Useful for testing and as a reference implementation.
 */
declare class InMemoryCreditRepository implements ICreditRepository {
    private users;
    private reservations;
    private transactions;
    private usageLogs;
    private journalEntries;
    getUserCredits(userId: string): Promise<PortableUserCredits | null>;
    initializeUserCredits(userId: string, tier: SubscriptionTier, initialBalance: number): Promise<PortableUserCredits>;
    updateUserCredits(userId: string, updates: CreditBalanceUpdate): Promise<void>;
    updateUserTier(userId: string, input: TierUpdateInput): Promise<void>;
    createReservation(input: CreateReservationInput): Promise<PortableReservation>;
    getReservation(userId: string, reservationId: string): Promise<PortableReservation | null>;
    updateReservationStatus(userId: string, reservationId: string, status: ReservationStatus, completedAt?: Date): Promise<void>;
    reserveCreditsAtomic(userId: string, amount: number, operationType: string, expiresAt: Date): Promise<PortableReservation>;
    commitReservationAtomic(userId: string, reservationId: string): Promise<void>;
    releaseReservationAtomic(userId: string, reservationId: string): Promise<void>;
    addCreditsAtomic(userId: string, amount: number, description: string, paymentRef?: string): Promise<void>;
    deductCreditsAtomic(userId: string, amount: number): Promise<{
        previousBalance: number;
        newBalance: number;
    }>;
    createTransaction(input: CreateTransactionInput): Promise<PortableTransaction>;
    getTransactions(userId: string, limit?: number, offset?: number): Promise<PortableTransaction[]>;
    logUsage(input: CreateUsageLogInput): Promise<PortableUsageLog>;
    getUsageLogs(query: UsageLogQuery): Promise<PortableUsageLog[]>;
    getUsageLogsCount(query: Omit<UsageLogQuery, "limit" | "offset">): Promise<number>;
    createJournalEntry(input: CreateJournalEntryInput): Promise<PortableJournalEntry>;
    getJournalEntries(query: JournalEntryQuery): Promise<PortableJournalEntry[]>;
    getJournalEntriesCount(query: Omit<JournalEntryQuery, "limit" | "offset">): Promise<number>;
    findAndExpireReservations(_batchSize?: number, _maxIterations?: number): Promise<{
        expiredCount: number;
        creditsReleased: number;
        errors: string[];
    }>;
    atomicMonthlyReset(userId: string, tier: SubscriptionTier, expectedResetAt: Date | string): Promise<MonthlyResetResult>;
    checkAndHandleSubscriptionExpiry(userId: string, gracePeriodDays?: number): Promise<SubscriptionExpiryResult>;
    /**
     * Clear all data (useful for testing)
     */
    clear(): void;
    /**
     * Get all users (useful for testing/debugging)
     */
    getAllUsers(): PortableUserCredits[];
    /**
     * Get all reservations for a user (useful for testing)
     */
    getAllReservations(userId: string): PortableReservation[];
}
/**
 * Create a new in-memory repository instance
 * Each call creates a fresh, isolated instance
 */
declare function createInMemoryCreditRepository(): InMemoryCreditRepository;

export { CreateJournalEntryInput, CreateReservationInput, CreateTransactionInput, CreateUsageLogInput, CreditBalanceUpdate, ICreditRepository, InMemoryCreditRepository, JournalEntryQuery, TierUpdateInput, UsageLogQuery, createInMemoryCreditRepository, generateId, getNextMonthlyReset, toDate };