import { type Duration, Effect, type Scope } from 'effect';
/**
 * Defers a `preserve(model)` call so that bursts of dispatches do not pay the
 * encoding cost on the hot path. `schedule` stashes the latest model and
 * (re)starts a debounce timer; only one `onDebounce` runs per quiet window.
 *
 * `flush` runs `onFlush` with the latest pending model synchronously: it
 * clears the pending slot atomically and invokes the callback, leaving any
 * in-flight timer fiber to wake up, observe an empty pending slot, and exit
 * as a no-op. Synchronous semantics let the runtime call this from
 * `vite:beforeFullReload` via `Effect.runSync`, with no race against Vite's
 * `location.reload()`. The two-callback split lets the flush path send
 * `isHmrReload: true` while debounced calls send `false`.
 *
 * `cancel` drops the pending model and interrupts the in-flight fiber.
 * Forked fibers are tied to the construction scope via `forkIn`, so scope
 * closure interrupts them too. `cancel` covers manual teardown.
 */
export type PreserveScheduler<Model> = Readonly<{
    schedule: (model: Model) => Effect.Effect<void>;
    flush: Effect.Effect<void>;
    cancel: Effect.Effect<void>;
}>;
export type PreserveSchedulerCallbacks<Model> = Readonly<{
    onDebounce: (model: Model) => Effect.Effect<void>;
    onFlush: (model: Model) => Effect.Effect<void>;
}>;
export declare const makePreserveScheduler: <Model>(callbacks: PreserveSchedulerCallbacks<Model>, delay: Duration.Input) => Effect.Effect<PreserveScheduler<Model>, never, Scope.Scope>;
//# sourceMappingURL=preserveScheduler.d.ts.map