/**
 * Marks one record as being written from an already-synced source so server
 * publish callbacks skip it (record-precise suppression). The framework's
 * routed sync replay apply uses this internally around every applied write, so
 * replayed device mutations never publish a second, server-origin sync change.
 * @param {ReturnType<typeof JSON.parse>} record - Server model record about to be written.
 * @returns {() => void} Release callback re-enabling publishing for the record.
 */
export declare function markServerApply(record: ReturnType<typeof JSON.parse>): () => void;
/**
 * Runs a callback with server publish callbacks suppressed - for code applying
 * already-synced data outside the framework's replay apply (importers,
 * backfills applying device-origin rows). Suppression covers the whole async
 * duration of the callback (nested calls stack) and is process-wide while it
 * runs: mutations from concurrently running requests are also suppressed for
 * that window, so prefer `markServerApply(record)` when other flows can
 * interleave.
 * @template T
 * @param {() => Promise<T> | T} callback - Work whose model writes should not publish sync changes.
 * @returns {Promise<T>} The callback result.
 */
export declare function withoutPublishing<T>(callback: () => Promise<T> | T): Promise<T>;
/**
 * Whether server publishing is currently suppressed for a record: either the
 * record was marked as a server apply (`markServerApply`) or a
 * `withoutPublishing` callback is running.
 * @param {ReturnType<typeof JSON.parse>} record - Server model record being written.
 * @returns {boolean} Whether publishing is suppressed for the record.
 */
export declare function isPublishingSuppressed(record: ReturnType<typeof JSON.parse>): boolean;
//# sourceMappingURL=sync-publish-suppression.d.ts.map