export { k as CompositeResolver, C as Container, D as DefaultMemberResolver, n as DefaultMemberResolverOptions, E as Err, M as MemberResolver, O as Ok, R as Result, h as all, l as createResolver, e as err, f as flatMap, a as isErr, i as isOk, m as map, d as mapErr, j as match, o as ok, t as tryCatch, g as tryCatchSync, u as unwrap, b as unwrapOr, c as unwrapOrElse } from '../resolver-DXtfO0qV.js';
export { p as BaseEvent, B as BeforeCheckInHookData, e as BeforeCheckOutHookData, s as CheckInFailedEvent, f as CheckInHookData, r as CheckInRecordedEvent, u as CheckOutFailedEvent, g as CheckOutHookData, t as CheckOutRecordedEvent, k as ClockInEventMap, j as ClockInEventPayload, o as ClockInEventType, C as ClockInPlugin, w as EngagementChangedEvent, E as EngagementHookData, h as EventBus, q as EventMemberInfo, x as MemberAtRiskEvent, y as MemberInactiveEvent, v as MilestoneAchievedEvent, M as MilestoneHookData, a as PluginContext, b as PluginHooks, D as PluginLogger, A as PluginManager, z as SessionExpiredEvent, S as StatsUpdatedEvent, i as createEventBus, d as definePlugin, l as loggingPlugin, m as metricsPlugin, n as notificationPlugin } from '../plugin-BI0AkTzA.js';
import { Connection, ClientSession } from 'mongoose';
import '../types.js';

/**
 * Transaction Helper
 *
 * Provides utilities for MongoDB transactions following Stripe/AWS patterns.
 * Matches the explicit session passing approach used in @classytic/payroll.
 *
 * @module @classytic/clockin/core/transaction
 */

/**
 * Transaction options
 */
interface TransactionOptions {
    /** Read concern level */
    readConcern?: 'local' | 'majority' | 'snapshot';
    /** Write concern */
    writeConcern?: {
        w: 'majority' | number;
        j?: boolean;
    };
    /** Read preference */
    readPreference?: 'primary' | 'primaryPreferred' | 'secondary' | 'secondaryPreferred' | 'nearest';
    /** Max commit time in ms */
    maxCommitTimeMS?: number;
}
/**
 * Execute a function within a MongoDB transaction.
 *
 * This is a convenience helper - users can also manage sessions manually
 * by passing `context.session` to operations.
 *
 * @example
 * ```typescript
 * import { withTransaction } from '@classytic/clockin';
 *
 * const result = await withTransaction(mongoose.connection, async (session) => {
 *   const checkInResult = await clockin.checkIn.record({
 *     member,
 *     targetModel: 'Membership',
 *     context: { organizationId, session },
 *   });
 *
 *   // Both operations are atomic
 *   await SomeOtherModel.create([{ ... }], { session });
 *
 *   return checkInResult;
 * });
 * ```
 */
declare function withTransaction<T>(connection: Connection, fn: (session: ClientSession) => Promise<T>, options?: TransactionOptions): Promise<T>;
/**
 * Execute a function with retry logic for transient transaction errors.
 *
 * MongoDB transactions can fail due to transient errors (e.g., write conflicts).
 * This helper automatically retries the entire transaction in such cases.
 *
 * @example
 * ```typescript
 * const result = await withTransactionRetry(
 *   mongoose.connection,
 *   async (session) => {
 *     // Your transactional operations
 *   },
 *   { maxRetries: 3 }
 * );
 * ```
 */
declare function withTransactionRetry<T>(connection: Connection, fn: (session: ClientSession) => Promise<T>, options?: TransactionOptions & {
    maxRetries?: number;
}): Promise<T>;
/**
 * Type guard to check if an object has a session property
 */
declare function hasSession(obj: unknown): obj is {
    session: ClientSession;
};
/**
 * Extract session from various input formats (context, options, etc.)
 */
declare function extractSession(input?: {
    session?: ClientSession;
} | null): ClientSession | undefined;

export { type TransactionOptions, extractSession, hasSession, withTransaction, withTransactionRetry };