import { Effect } from 'effect';
import type { DecodedEntity, DecodedSingleEntity } from '../../core/index.js';
import type { AnyEntityESchema, AnyUnkeyedESchema } from '../../eschema/index.js';
import { type PaceStrategyFactory } from '../collection/pacing/index.js';
import type { DeletePayload, StdCollectionOptions, UpdatePayload } from '../domain/collection-item/index.js';
import type { SyncReporter } from '../domain/sync-event/index.js';
import { type OfflineActionConfig } from '../outbox/outbox/index.js';
import type { StdSyncPlatform } from '../platform/contract/index.js';
import type { Collection } from '@tanstack/react-db';
import type { CollectionItem } from '../domain/collection-item/index.js';
import { type EffectRuntime } from '../platform/effect-runner/index.js';
import { bidirectional, newToOld, oldToNew, type CadenceConfig, type PartitionEntry, type PartitionMap, type SingleItemSourceConfig, type SingleItemStrategy } from '../strategy/strategy/index.js';
import { type FlowPlacement } from '../flow/sync-flow/index.js';
export declare const syncStrategy: {
    oldToNew: typeof oldToNew;
    newToOld: typeof newToOld;
    bidirectional: typeof bidirectional;
};
export declare const paceStrategy: {
    coalesce: (options?: import("../collection/pacing/coalesce-strategy.js").CoalesceStrategyOptions) => PaceStrategyFactory;
    debounce: (options: import("@tanstack/react-db").DebounceStrategyOptions) => PaceStrategyFactory;
    throttle: (options: import("@tanstack/react-db").ThrottleStrategyOptions) => PaceStrategyFactory;
    queue: (options?: import("@tanstack/react-db").QueueStrategyOptions) => PaceStrategyFactory;
};
type SyncShape<S extends AnyEntityESchema, R = never> = {
    total: PartitionEntry<S['Type'], R, any>;
    partitions?: PartitionMap<S, R>;
} | {
    total?: PartitionEntry<S['Type'], R, any>;
    partitions: PartitionMap<S, R>;
};
export type SyncConfig<S extends AnyEntityESchema, R = never> = {
    schema: S;
    sync?: SyncShape<S, R>;
    options?: StdCollectionOptions<S['Type']>;
    onInsert?: (items: ReadonlyArray<S['Type']>) => Effect.Effect<ReadonlyArray<DecodedEntity<S['Type']>>, unknown, R>;
    onUpdate?: (payload: UpdatePayload<S['Type'], S>) => Effect.Effect<DecodedEntity<S['Type']>, unknown, R>;
    onDelete?: (payload: DeletePayload<S['Type']>) => Effect.Effect<DecodedEntity<S['Type']>, unknown, R>;
    pacing?: PaceStrategyFactory;
    outbox?: boolean;
};
type SingleItemSyncBase<S extends AnyUnkeyedESchema, R = never> = {
    schema: S;
    options?: StdCollectionOptions<S['Type']>;
    onUpdate?: (payload: {
        updates: Partial<S['Type']>;
    }) => Effect.Effect<DecodedSingleEntity<S['Type']>, unknown, R>;
    pacing?: PaceStrategyFactory;
    outbox?: boolean;
};
export type SingleItemSyncConfig<S extends AnyUnkeyedESchema, R = never, TState = unknown> = SingleItemSyncBase<S, R> & ({
    source: SingleItemSourceConfig<S['Type'], R>['source'];
    strategy?: never;
} | {
    source?: never;
    strategy: SingleItemStrategy<S['Type'], TState, R>;
});
export type StdSyncDefaults<R = never> = {
    name: string;
    version?: string | number;
    options?: StdCollectionOptions<object>;
    platform?: StdSyncPlatform;
    cadence?: CadenceConfig;
    runtime?: EffectRuntime<R>;
    onEvent?: SyncReporter<R>;
    flow?: FlowPlacement;
    outbox?: boolean;
};
declare const makeStdSync: <R>(defaults: StdSyncDefaults<R>) => {
    flow: {
        id: string;
        participant: (name: string) => import("../flow/sync-flow/sync-flow.js").FlowLane;
    };
    sync: <S extends AnyEntityESchema>(config: SyncConfig<S, R>) => {
        id?: string;
        schema: import("../domain/collection-item/collection-item.js").CollectionItemSchema<S>;
        getKey: (item: CollectionItem<S["Type"]>) => string;
        gcTime?: number;
        startSync?: boolean;
        autoIndex?: `off` | `eager`;
        defaultIndexType?: import("@tanstack/react-db").IndexConstructor<string>;
        compare?: (x: CollectionItem<S["Type"]>, y: CollectionItem<S["Type"]>) => number;
        syncMode?: import("@tanstack/react-db").SyncMode;
        onInsert?: import("@tanstack/react-db").InsertMutationFn<CollectionItem<S["Type"]>, string, import("../collection/keyed-collection/keyed-collection.js").KeyedCollectionUtils<S>, any>;
        onUpdate?: import("@tanstack/react-db").UpdateMutationFn<CollectionItem<S["Type"]>, string, import("../collection/keyed-collection/keyed-collection.js").KeyedCollectionUtils<S>, any>;
        onDelete?: import("@tanstack/react-db").DeleteMutationFn<CollectionItem<S["Type"]>, string, import("../collection/keyed-collection/keyed-collection.js").KeyedCollectionUtils<S>, any>;
        defaultStringCollation?: import("@tanstack/react-db").StringCollationConfig;
        utils: import("../collection/keyed-collection/keyed-collection.js").KeyedCollectionUtils<S>;
        sync: import("@tanstack/react-db").SyncConfig<CollectionItem<S["Type"]>, string>;
    };
    singleItemSync: <S extends AnyUnkeyedESchema, TState>(config: SingleItemSyncConfig<S, R, TState>) => import("../collection/single-item-collection/single-item-collection.js").SingleItemResult<S["Type"], S>;
    collection: <S extends AnyEntityESchema>(config: SyncConfig<S, R>) => Collection<CollectionItem<S["Type"]> extends object ? CollectionItem<S["Type"]> : Record<string, unknown>, string, import("../collection/keyed-collection/keyed-collection.js").KeyedCollectionUtils<S>, import("../domain/collection-item/collection-item.js").CollectionItemSchema<S>, CollectionItem<S["Type"]> extends object ? CollectionItem<S["Type"]> : Record<string, unknown>> & import("@tanstack/react-db").NonSingleResult;
    singleItemCollection: <S extends AnyUnkeyedESchema, TState>(config: SingleItemSyncConfig<S, R, TState>) => Collection<CollectionItem<S["Type"]> extends object ? CollectionItem<S["Type"]> : Record<string, unknown>, string, import("@tanstack/react-db").UtilsRecord, import("../domain/collection-item/collection-item.js").CollectionItemSchema<S>, CollectionItem<S["Type"]> extends object ? CollectionItem<S["Type"]> : Record<string, unknown>> & import("@tanstack/react-db").SingleResult;
    createOfflineAction: <P>(action: OfflineActionConfig<P, R>) => (payload: P) => import("../outbox/offline-action/offline-action.js").OfflineActionTransaction;
    reset: () => Promise<void>;
    outbox: {
        entity: import("../../db/db.js").KeyedEntity<"sync-store", import("../../eschema/index.js").EntityESchema<"SyncStoredOutboxEntry", "key", "v1", {
            sync: import("effect/Schema").String;
            name: import("effect/Schema").String;
            queue: import("effect/Schema").String;
            status: import("effect/Schema").Literals<readonly ["pending", "in-flight", "failed"]>;
            enqueuedAt: import("effect/Schema").String;
            body: import("effect/Schema").Codec<import("../domain/stored-entity/table.js").OpaqueValue, import("../domain/stored-entity/table.js").OpaqueValue, never, never>;
        } & Record<"key", import("effect/Schema").Codec<string, string, never, never>>>, readonly ["sync"], Record<"primary", import("../../db/db.js").AccessPatternDefinition<undefined, "primary", readonly ["sync"], readonly ["key"]>> & Record<"byQueue", import("../../db/db.js").AccessPatternDefinition<"LSI1", "lsi", readonly ["sync"], readonly ["queue"]>>>;
        transaction: (id: string) => import("@tanstack/react-db").Transaction<Record<string, unknown>> | null;
        discard: (id: string) => Promise<void>;
    };
    registry: () => {
        process: (message: unknown) => void;
    };
    dispose: () => Promise<void>;
};
type CreateStdSync = {
    <R>(defaults: StdSyncDefaults<R> & {
        runtime: EffectRuntime<R>;
    }): ReturnType<typeof makeStdSync<R>>;
    (defaults: StdSyncDefaults<never> & {
        runtime?: never;
    }): ReturnType<typeof makeStdSync<never>>;
};
export declare const createStdSync: CreateStdSync;
export type { EffectRuntime } from '../platform/effect-runner/index.js';
export type { FlowLane, FlowPlacement } from '../flow/sync-flow/index.js';
export type { PeerChannel, PeerChannelFactory, } from '../domain/peer-channel/index.js';
export type { LeadershipState, SyncEvent } from '../domain/sync-event/index.js';
export type { SyncReporter } from '../domain/sync-event/index.js';
export type { Connectivity } from '../domain/connectivity/index.js';
export { OutboxUnreachable } from '../outbox/outbox/index.js';
export type { PartitionedStrategy, SingleItemStrategy, StrategyContext, } from '../strategy/strategy/index.js';
export { syncStore } from '../domain/stored-entity/index.js';
export type { SyncStoreLayer } from '../platform/sync-store/index.js';
export type { LeadershipLayer } from '../platform/leadership/index.js';
export type { StdSyncPlatform } from '../platform/contract/index.js';
/** Public read surface returned by a keyed std-sync collection. */
export type SyncedCollection<T extends object> = Collection<CollectionItem<T>, string>;
//# sourceMappingURL=std-sync.d.ts.map