@nehorai/credits 1.7.0 → 2.0.0

package/dist/types-C8hZMe8a.d.cts

@@ -0,0 +1,646 @@
+import { P as PortableTransaction, a as PortableReservation, R as ReservationStatus, C as CreditOperationType, b as CreditSource, J as JournalReferenceType, A as AIProviderType, S as SubscriptionTier, c as PortableUserCredits, d as PortableUsageLog, M as MonthlyResetResult, e as SubscriptionExpiryResult, f as PortableJournalEntry } from './types-DJ8yqaVr.cjs';
+
+/**
+ * Typed outcomes for the V2 reservation boundary.
+ *
+ * The legacy `*Atomic` repository methods signal "you lost the race" by
+ * throwing (or, worse, by silently returning). V2 makes every terminal
+ * transition an explicit, serialisable value so callers can tell a winner
+ * from a duplicate delivery without string-matching an error message.
+ *
+ * Every outcome is discriminated on `outcome` (never `status`, which is the
+ * reservation's own lifecycle field and would collide).
+ */
+
+/** Statuses a reservation can no longer transition out of. */
+type TerminalReservationStatus = Exclude<ReservationStatus, "reserved">;
+/**
+ * Result of `reserveCreditsV2`.
+ *
+ * - `created` — this caller minted the hold.
+ * - `replayed` — same `(userId, idempotencyKey)` with an identical immutable
+ *   payload; the original reservation is returned and no new hold was placed.
+ * - `insufficient` — the guarded hold could not be placed; nothing was written.
+ * - `idempotency_conflict` — the key was reused with a different
+ *   amount/operation. Nothing was written; the existing reservation is
+ *   returned so the caller can diff it.
+ */
+type ReserveOutcome = {
+    outcome: "created";
+    reservation: PortableReservation;
+} | {
+    outcome: "replayed";
+    reservation: PortableReservation;
+} | {
+    outcome: "insufficient";
+    available: number;
+    required: number;
+    shortfall: number;
+} | {
+    outcome: "idempotency_conflict";
+    idempotencyKey: string;
+    existing: PortableReservation;
+};
+/**
+ * Result of `commitReservationV2`.
+ *
+ * Exactly one concurrent caller ever observes `committed`; that call — and
+ * only that call — moved the balance and wrote the journal entry.
+ */
+type CommitOutcome = {
+    outcome: "committed";
+    reservation: PortableReservation;
+    amount: number;
+    /** `balance + bonusCredits` after the deduction, read from the same UPDATE. */
+    balanceAfter: number;
+    journalEntryId: string;
+} | {
+    outcome: "already_terminal";
+    reservation: PortableReservation;
+    terminalStatus: TerminalReservationStatus;
+} | {
+    outcome: "not_found";
+    reservationId: string;
+};
+/** Result of `releaseReservationV2`. Mirrors {@link CommitOutcome}. */
+type ReleaseOutcome = {
+    outcome: "released";
+    reservation: PortableReservation;
+    amount: number;
+    journalEntryId: string;
+} | {
+    outcome: "already_terminal";
+    reservation: PortableReservation;
+    terminalStatus: TerminalReservationStatus;
+} | {
+    outcome: "not_found";
+    reservationId: string;
+};
+/**
+ * Result of `expireReservationV2`.
+ *
+ * `not_due` means the reservation is still `reserved` but its `expiresAt` is
+ * in the future relative to the sweep's `asOf` — a no-op, not a failure.
+ */
+type ExpireOutcome = {
+    outcome: "expired";
+    reservation: PortableReservation;
+    amount: number;
+    journalEntryId: string;
+} | {
+    outcome: "not_due";
+    reservation: PortableReservation;
+} | {
+    outcome: "already_terminal";
+    reservation: PortableReservation;
+    terminalStatus: TerminalReservationStatus;
+} | {
+    outcome: "not_found";
+    reservationId: string;
+};
+/**
+ * Result of crediting an account against a `paymentRef`.
+ *
+ * - `created` — this delivery credited the account.
+ * - `replayed` — the reference was already used for the *same* credit event;
+ *   nothing was written and the original transaction is returned.
+ * - `conflict` — the reference was already used for a *different* event
+ *   (another user, another amount, another source). Nothing was written;
+ *   `mismatch` names the first field that disagreed.
+ *
+ * A call with no `paymentRef` is always `created`: without a reference there is
+ * nothing to deduplicate on, and every delivery is a distinct credit.
+ *
+ * **`created` is only a single-delivery guarantee on an adapter that implements
+ * `addCreditsV2`.** Routed through a legacy adapter, `created` means "the call
+ * was made and did not throw" — there is no global unique index behind it, so a
+ * re-delivered reference credits again. `supportsIdempotentCredit` is the probe
+ * that tells the two apart, and it is also why `transaction` is optional here:
+ * the legacy method returns nothing, and inventing a transaction to fill the
+ * field would be a fabricated audit record.
+ */
+type AddCreditsOutcome = {
+    outcome: "created";
+    /** The reference this credit was recorded under, if there was one. */
+    paymentRef?: string;
+    /** Absent only on the legacy fallback path; see above. */
+    transaction?: PortableTransaction;
+    /** Absent only on the legacy fallback path; see above. */
+    journalEntryId?: string;
+} | {
+    outcome: "replayed";
+    paymentRef: string;
+    transaction: PortableTransaction;
+} | {
+    outcome: "conflict";
+    paymentRef: string;
+    existing: PortableTransaction;
+    /** The first field of the canonical payload that disagreed. */
+    mismatch: string;
+};
+/** True when this delivery actually moved credits. */
+declare function isCreditedOutcome(outcome: AddCreditsOutcome): outcome is Extract<AddCreditsOutcome, {
+    outcome: "created";
+}>;
+/** True when this caller performed the state transition. */
+declare function isWinningOutcome(outcome: CommitOutcome | ReleaseOutcome | ExpireOutcome): boolean;
+/** Narrow a reserve outcome to the two cases that yield a usable reservation. */
+declare function isReservedOutcome(outcome: ReserveOutcome): outcome is Extract<ReserveOutcome, {
+    reservation: PortableReservation;
+}>;
+
+/**
+ * Inputs for the V2 reservation boundary.
+ *
+ * V2 is additive: every method is optional on {@link ICreditRepository} so
+ * existing adapters keep compiling and keep working through the legacy
+ * `*Atomic` methods. Adapters that implement V2 must satisfy the contract
+ * documented on {@link ICreditRepositoryV2}.
+ */
+
+/**
+ * Input for `reserveCreditsV2`.
+ *
+ * `userId`, `amount` and `operationType` form the immutable payload bound to
+ * `idempotencyKey`: replaying the same key with the same payload returns the
+ * original reservation, replaying it with a different one is a conflict.
+ * `expiresAt` is deliberately *not* part of the payload — a retry naturally
+ * computes a later deadline and that must not be treated as a conflict.
+ */
+interface ReserveCreditsV2Input {
+    userId: string;
+    amount: number;
+    operationType: CreditOperationType;
+    expiresAt: Date;
+    /**
+     * Caller-supplied key, unique per user. Omit it to get legacy
+     * (non-idempotent) reserve semantics — every call mints a new hold.
+     */
+    idempotencyKey?: string;
+}
+/** Optional journal customisation for a V2 state transition. */
+interface ReservationTransitionOptions {
+    /** Overrides the generated journal description. */
+    description?: string;
+    /** Merged onto the journal entry's metadata. */
+    metadata?: Record<string, unknown>;
+}
+/** Options for `expireReservationV2`. */
+interface ExpireReservationV2Options extends ReservationTransitionOptions {
+    /**
+     * Sweep timestamp. A reservation only expires when `expiresAt <= asOf`;
+     * otherwise the outcome is `not_due`. Defaults to now.
+     */
+    asOf?: Date;
+}
+/**
+ * The V2 surface. Every method must:
+ *
+ * 1. run in a single database transaction;
+ * 2. take row locks in a consistent order — reservation first, then balance —
+ *    so concurrent transitions cannot deadlock;
+ * 3. transition status with a compare-and-set (`WHERE status = 'reserved'`)
+ *    and report the loser truthfully instead of silently succeeding;
+ * 4. mutate balances with column expressions, never with values read earlier
+ *    in the transaction;
+ * 5. write at most one journal entry, inside the same transaction, keyed so a
+ *    retry cannot duplicate it;
+ * 6. perform no callbacks and no network I/O inside the transaction.
+ */
+interface ICreditRepositoryV2 {
+    reserveCreditsV2(input: ReserveCreditsV2Input): Promise<ReserveOutcome>;
+    commitReservationV2(userId: string, reservationId: string, options?: ReservationTransitionOptions): Promise<CommitOutcome>;
+    releaseReservationV2(userId: string, reservationId: string, options?: ReservationTransitionOptions): Promise<ReleaseOutcome>;
+    expireReservationV2(userId: string, reservationId: string, options?: ExpireReservationV2Options): Promise<ExpireOutcome>;
+}
+/** Input for `addCreditsV2`. */
+interface AddCreditsV2Input {
+    userId: string;
+    amount: number;
+    description: string;
+    /**
+     * Global idempotency key for the credit event. Empty and whitespace-only
+     * strings normalise to "no reference" — see `normalizePaymentRef`.
+     */
+    paymentRef?: string;
+    options?: AddCreditsAtomicOptions;
+}
+/**
+ * The idempotent credit surface, separate from {@link ICreditRepositoryV2}.
+ *
+ * It is its own interface with its own probe because the two capabilities are
+ * genuinely independent: an adapter can serialise reservations without having a
+ * unique index over `payment_ref`, and folding this into the reservation probe
+ * would make `supportsCreditsV2` narrow third-party adapters to a method they
+ * never wrote.
+ *
+ * An implementation must:
+ *
+ * 1. run in a single transaction;
+ * 2. resolve a non-empty reference to exactly one of `created` / `replayed` /
+ *    `conflict`, comparing the canonical payload — not merely the reference's
+ *    presence — before reporting a replay;
+ * 3. write nothing at all on `replayed` or `conflict`;
+ * 4. enforce the reference *globally*, so the same reference cannot credit two
+ *    different users;
+ * 5. fail closed if the uniqueness it relies on is not actually in place.
+ */
+interface ICreditRepositoryCreditsV2 {
+    addCreditsV2(input: AddCreditsV2Input): Promise<AddCreditsOutcome>;
+}
+/**
+ * Deterministic journal key for a reservation transition.
+ *
+ * Derived purely from the reservation id and the transition, so a retried
+ * commit computes the same key and collides with the first entry on the
+ * journal's partial unique index instead of writing a second row.
+ */
+declare function reservationJournalKey(reservationId: string, transition: "commit" | "release" | "expire"): string;
+
+/**
+ * Input for creating a credit reservation
+ */
+interface CreateReservationInput {
+    userId: string;
+    amount: number;
+    operationType: CreditOperationType;
+    expiresAt: Date;
+    /**
+     * @deprecated Rejected — this writer does not place the hold.
+     *
+     * `createReservation` inserts a row and leaves `reserved` alone, so a keyed
+     * row written here names a hold that does not exist, and `reserveCreditsV2`
+     * would adopt it as a `replayed` reservation whose commit then spends another
+     * hold's coverage. Both adapters throw `UNSUPPORTED_OPERATION` when this is
+     * set. Pass the key to `reserveCredits` / `reserveCreditsV2` instead, which
+     * claims the key and places the hold in one transaction.
+     *
+     * The field is kept rather than deleted so the refusal reaches a JavaScript
+     * caller as a typed error instead of a silently ignored property.
+     */
+    idempotencyKey?: string;
+}
+/**
+ * Input for creating a credit transaction
+ */
+interface CreateTransactionInput {
+    userId: string;
+    type: PortableTransaction["type"];
+    amount: number;
+    description: string;
+    paymentRef?: string;
+    previousBalance: number;
+    newBalance: number;
+}
+/**
+ * Input for logging usage
+ */
+interface CreateUsageLogInput {
+    userId: string;
+    operationType: CreditOperationType;
+    provider: AIProviderType;
+    creditsUsed: number;
+    success: boolean;
+    errorMessage?: string;
+    resourceId?: string;
+    resourceType?: string;
+    requestId?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Query options for usage logs
+ */
+interface UsageLogQuery {
+    userId?: string;
+    operationType?: CreditOperationType;
+    success?: boolean;
+    limit?: number;
+    offset?: number;
+    startDate?: Date;
+    endDate?: Date;
+}
+/**
+ * Input for creating a journal entry
+ */
+interface CreateJournalEntryInput {
+    userId: string;
+    entryType: "debit" | "credit";
+    amount: number;
+    balanceAfter: number;
+    source: CreditSource;
+    referenceId: string;
+    referenceType: JournalReferenceType;
+    description: string;
+    metadata?: Record<string, unknown>;
+    /** Deterministic key making this entry unique per user (V2, optional). */
+    idempotencyKey?: string;
+}
+/**
+ * Query options for journal entries
+ */
+interface JournalEntryQuery {
+    userId: string;
+    source?: CreditSource;
+    referenceType?: JournalReferenceType;
+    limit?: number;
+    offset?: number;
+    startDate?: Date;
+    endDate?: Date;
+}
+/**
+ * Partial update for user credits balance
+ */
+interface CreditBalanceUpdate {
+    balance?: number;
+    bonusCredits?: number;
+    reserved?: number;
+    tier?: SubscriptionTier;
+    monthlyLimit?: number;
+    monthlyUsed?: number;
+    monthlyResetAt?: Date | string;
+    subscriptionExpiresAt?: Date | string | null;
+    /** Increment balance by this amount (alternative to absolute value) */
+    balanceIncrement?: number;
+    /** Increment bonusCredits by this amount (alternative to absolute value) */
+    bonusCreditsIncrement?: number;
+    /** Increment reserved by this amount (alternative to absolute value) */
+    reservedIncrement?: number;
+    /** Increment monthlyUsed by this amount */
+    monthlyUsedIncrement?: number;
+}
+/**
+ * Input for tier update
+ */
+interface TierUpdateInput {
+    tier: SubscriptionTier;
+    monthlyLimit: number;
+    balance?: number;
+    monthlyUsed?: number;
+    subscriptionExpiresAt?: Date | string | null;
+}
+/**
+ * Optional journal customization for `addCreditsAtomic`.
+ *
+ * By default a credit add records a journal entry with `source: "purchase"`,
+ * `referenceType: "transaction"`, and `{ paymentRef }` metadata. These options
+ * let callers override that — e.g. tag a signup grant as `source: "bonus"`, or
+ * carry revenue-attribution fields (gross amount, credits granted) so a single
+ * journal can serve as the app's revenue ledger.
+ */
+interface AddCreditsAtomicOptions {
+    /** Journal entry source (defaults to `"purchase"`). */
+    source?: CreditSource;
+    /** Journal reference type (defaults to `"transaction"`). */
+    referenceType?: JournalReferenceType;
+    /**
+     * Extra metadata merged onto the journal entry. When `paymentRef` is present
+     * it is merged in too (explicit keys here win on collision).
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Repository interface for credits database operations
+ *
+ * Implementations can use any database (Firestore, PostgreSQL, etc.)
+ * All methods should handle their own error handling and transactions
+ */
+interface ICreditRepository extends Partial<ICreditRepositoryV2>, Partial<ICreditRepositoryCreditsV2> {
+    /**
+     * Get user credits balance
+     * @param userId - User ID
+     * @returns User credits or null if not found
+     */
+    getUserCredits(userId: string): Promise<PortableUserCredits | null>;
+    /**
+     * Initialize credits for a new user
+     * @param userId - User ID
+     * @param tier - Initial subscription tier
+     * @param initialBalance - Initial credit balance
+     * @returns Initialized user credits
+     */
+    initializeUserCredits(userId: string, tier: SubscriptionTier, initialBalance: number): Promise<PortableUserCredits>;
+    /**
+     * Update user credits balance
+     * @param userId - User ID
+     * @param updates - Partial updates to apply
+     */
+    updateUserCredits(userId: string, updates: CreditBalanceUpdate): Promise<void>;
+    /**
+     * Update user subscription tier
+     * @param userId - User ID
+     * @param input - Tier update data
+     */
+    updateUserTier(userId: string, input: TierUpdateInput): Promise<void>;
+    /**
+     * Create a reservation *record* — not a hold.
+     *
+     * Writes a row and leaves `reserved` untouched, so the row is not backed by
+     * credits and no settlement path will move money for it: the commit /
+     * release / expire transitions (legacy and V2 alike) refuse it with
+     * `UNBACKED_RESERVATION`, and it refuses an `idempotencyKey` so it can never
+     * be adopted as a V2 replay. Use it for imported or annotation-only records.
+     *
+     * To place a hold that can actually be committed, call `reserveCreditsAtomic`
+     * or `reserveCreditsV2` — they raise `reserved` and write the row in one
+     * atomic step.
+     *
+     * @param input - Reservation data
+     * @returns Created reservation record
+     */
+    createReservation(input: CreateReservationInput): Promise<PortableReservation>;
+    /**
+     * Get a reservation by ID
+     * @param userId - User ID
+     * @param reservationId - Reservation ID
+     * @returns Reservation or null
+     */
+    getReservation(userId: string, reservationId: string): Promise<PortableReservation | null>;
+    /**
+     * Annotate a reservation *record* with a status.
+     *
+     * Assigns a status and nothing else — no balance movement, no `reserved`
+     * adjustment, no journal entry. It therefore refuses two writes that would
+     * make the status lie about the ledger: any write to a row whose hold was
+     * atomically placed (those statuses belong to commit/release/expire), and
+     * any write back to `reserved` (nothing here re-places a hold). Rows written
+     * by `createReservation` accept terminal statuses freely.
+     *
+     * @param userId - User ID
+     * @param reservationId - Reservation ID
+     * @param status - New status
+     * @param completedAt - Completion timestamp
+     */
+    updateReservationStatus(userId: string, reservationId: string, status: ReservationStatus, completedAt?: Date): Promise<void>;
+    /**
+     * Reserve credits atomically (creates reservation + updates balance in transaction)
+     * @param userId - User ID
+     * @param amount - Credits to reserve
+     * @param operationType - Operation type for tracking
+     * @param expiresAt - Reservation expiry time
+     * @returns Created reservation
+     * @throws Error if insufficient credits
+     */
+    reserveCreditsAtomic(userId: string, amount: number, operationType: CreditOperationType, expiresAt: Date): Promise<PortableReservation>;
+    /**
+     * Commit a reservation atomically (deducts credits + marks reservation committed)
+     * @param userId - User ID
+     * @param reservationId - Reservation ID
+     * @throws Error if reservation not found or not in reserved state
+     */
+    commitReservationAtomic(userId: string, reservationId: string): Promise<void>;
+    /**
+     * Release a reservation atomically (releases reserved credits + marks reservation released)
+     * @param userId - User ID
+     * @param reservationId - Reservation ID
+     */
+    releaseReservationAtomic(userId: string, reservationId: string): Promise<void>;
+    /**
+     * Add credits atomically (creates transaction + updates balance)
+     * @param userId - User ID
+     * @param amount - Credits to add
+     * @param description - Transaction description
+     * @param paymentRef - Optional payment reference
+     * @param options - Optional journal source / reference type / extra metadata
+     *   for the credit journal entry (e.g. revenue attribution fields). Lets
+     *   callers record a purchase's gross amount, a bonus/refund source, etc.,
+     *   instead of the default `source: "purchase"` + `{ paymentRef }` metadata.
+     */
+    addCreditsAtomic(userId: string, amount: number, description: string, paymentRef?: string, options?: AddCreditsAtomicOptions): Promise<void>;
+    /**
+     * Deduct credits from a user's balance atomically.
+     *
+     * Splits the deduction across `balance` and `bonusCredits`, draining
+     * `balance` (monthly, resets each cycle) first so persistent bonus
+     * credits survive longer. Runs in a single atomic transaction so
+     * concurrent deducts cannot drive either field negative.
+     *
+     * Callers are responsible for writing any audit record (journal /
+     * transaction) — this method only moves credits.
+     *
+     * @param userId - User ID
+     * @param amount - Credits to deduct (positive)
+     * @returns Combined totals (balance + bonusCredits) before and after.
+     * @throws If user has no credits doc or insufficient credits
+     */
+    deductCreditsAtomic(userId: string, amount: number): Promise<{
+        previousBalance: number;
+        newBalance: number;
+    }>;
+    /**
+     * Create a credit transaction *record* — no balance moves.
+     *
+     * Refuses a `paymentRef`: the reference is the global identity of a credit
+     * event, and a record that carried one without crediting anyone would make a
+     * later `addCredits` with the same reference report `replayed` and credit
+     * nothing. Deliver referenced payments through `addCreditsAtomic` /
+     * `addCreditsV2`, which claim the reference and move the balance atomically.
+     *
+     * @param input - Transaction data
+     * @returns Created transaction
+     */
+    createTransaction(input: CreateTransactionInput): Promise<PortableTransaction>;
+    /**
+     * Get user's transaction history
+     * @param userId - User ID
+     * @param limit - Max results
+     * @param offset - Skip results
+     * @returns List of transactions
+     */
+    getTransactions(userId: string, limit?: number, offset?: number): Promise<PortableTransaction[]>;
+    /**
+     * Log a usage event
+     * @param input - Usage log data
+     * @returns Created usage log
+     */
+    logUsage(input: CreateUsageLogInput): Promise<PortableUsageLog>;
+    /**
+     * Query usage logs
+     * @param query - Query parameters
+     * @returns List of usage logs
+     */
+    getUsageLogs(query: UsageLogQuery): Promise<PortableUsageLog[]>;
+    /**
+     * Get usage log count (for pagination)
+     * @param query - Query parameters (without limit/offset)
+     * @returns Count of matching logs
+     */
+    getUsageLogsCount(query: Omit<UsageLogQuery, "limit" | "offset">): Promise<number>;
+    /**
+     * Find and expire reservations past their expiration time
+     * Used by cron job to clean up stale reservations
+     * @param batchSize - Maximum number of reservations to process per batch (default: 100)
+     * @param maxIterations - Maximum number of pagination iterations to prevent infinite loops (default: 100)
+     * @returns Cleanup results with counts and errors
+     */
+    findAndExpireReservations(batchSize?: number, maxIterations?: number): Promise<{
+        expiredCount: number;
+        creditsReleased: number;
+        errors: string[];
+    }>;
+    /**
+     * Atomically perform monthly reset if needed
+     * Uses optimistic locking to prevent race conditions
+     *
+     * @param userId - User ID
+     * @param tier - User's current subscription tier (for determining new balance)
+     * @param expectedResetAt - The expected monthlyResetAt value (for optimistic locking)
+     * @returns Result indicating whether reset was performed and updated credits
+     */
+    atomicMonthlyReset(userId: string, tier: SubscriptionTier, expectedResetAt: Date | string): Promise<MonthlyResetResult>;
+    /**
+     * Check and handle subscription expiry with grace period
+     * Auto-downgrades expired subscriptions after grace period
+     *
+     * @param userId - User ID
+     * @param gracePeriodDays - Days to allow after expiry before downgrade (default: 3)
+     * @returns Result indicating whether downgrade occurred
+     */
+    checkAndHandleSubscriptionExpiry(userId: string, gracePeriodDays?: number): Promise<SubscriptionExpiryResult>;
+    /**
+     * Create a journal entry for audit trail
+     * @param input - Journal entry data
+     * @returns Created journal entry
+     */
+    createJournalEntry(input: CreateJournalEntryInput): Promise<PortableJournalEntry>;
+    /**
+     * Get journal entries for a user
+     * @param query - Query parameters
+     * @returns List of journal entries
+     */
+    getJournalEntries(query: JournalEntryQuery): Promise<PortableJournalEntry[]>;
+    /**
+     * Get journal entry count for pagination
+     * @param query - Query parameters (without limit/offset)
+     * @returns Count of matching entries
+     */
+    getJournalEntriesCount(query: Omit<JournalEntryQuery, "limit" | "offset">): Promise<number>;
+}
+/**
+ * Factory type for creating repository instances
+ */
+type CreditRepositoryFactory = () => ICreditRepository;
+/**
+ * Narrow a repository to one that implements the full V2 boundary.
+ *
+ * V2 methods are optional on {@link ICreditRepository}, so callers that need
+ * the idempotent/race-safe path must probe rather than assume. A repository
+ * only counts as V2 when it implements *all four* transitions — a partial
+ * implementation would leave one path silently unsafe.
+ */
+declare function supportsCreditsV2(repository: ICreditRepository): repository is ICreditRepository & ICreditRepositoryV2;
+/**
+ * Narrow a repository to one that credits idempotently against a `paymentRef`.
+ *
+ * Deliberately a separate probe from {@link supportsCreditsV2}: serialising
+ * reservations and enforcing a global payment reference are different
+ * guarantees resting on different database objects, and an adapter may have one
+ * without the other.
+ */
+declare function supportsIdempotentCredit(repository: ICreditRepository): repository is ICreditRepository & ICreditRepositoryCreditsV2;
+/**
+ * Convert PortableUserCredits to client-safe format
+ * Utility function that implementations can use
+ */
+declare function toClientUserCredits(credits: PortableUserCredits): PortableUserCredits;
+
+export { type AddCreditsAtomicOptions as A, type CommitOutcome as C, type ExpireOutcome as E, type ICreditRepository as I, type JournalEntryQuery as J, type ReleaseOutcome as R, type TerminalReservationStatus as T, type UsageLogQuery as U, type AddCreditsOutcome as a, type AddCreditsV2Input as b, type CreateJournalEntryInput as c, type CreateReservationInput as d, type CreateTransactionInput as e, type CreateUsageLogInput as f, type CreditBalanceUpdate as g, type CreditRepositoryFactory as h, type ExpireReservationV2Options as i, type ICreditRepositoryCreditsV2 as j, type ICreditRepositoryV2 as k, type ReservationTransitionOptions as l, type ReserveCreditsV2Input as m, type ReserveOutcome as n, type TierUpdateInput as o, isCreditedOutcome as p, isReservedOutcome as q, isWinningOutcome as r, reservationJournalKey as s, supportsCreditsV2 as t, supportsIdempotentCredit as u, toClientUserCredits as v };