import { Cause, DateTime, Effect, Schema } from "effect";
import type { Success as EffectSuccess } from "effect/Effect";
import { DdfHttp } from "./client.js";
import type { DdfHttpError } from "./client.js";
import { getMember, getOffice, getOpenHouse, getProperty } from "./resources.js";
import type { MediaType } from "./schema/mediaSchema.js";
import type { SocialMedia } from "./schema/officeSchema.js";
import type { RoomsType } from "./schema/roomsSchema.js";
import type { ODataListQuery, ReplicationQuery } from "./types.js";
export declare const SyncModeSchema: Schema.Literals<readonly ["initial", "incremental"]>;
export declare const SyncResourceSchema: Schema.Literals<readonly ["Destination", "Property", "Member", "Office", "OpenHouse"]>;
export type SyncMode = typeof SyncModeSchema.Type;
export type SyncResource = typeof SyncResourceSchema.Type;
export type SyncStage = "hydrate" | "persist";
export type PropertyRecord = EffectSuccess<ReturnType<typeof getProperty>>;
export type MemberRecord = EffectSuccess<ReturnType<typeof getMember>>;
export type OfficeRecord = EffectSuccess<ReturnType<typeof getOffice>>;
export type OpenHouseRecord = EffectSuccess<ReturnType<typeof getOpenHouse>>;
export type RoomRecord = RoomsType[number];
export type MediaRecord = MediaType[number];
declare const DdfReplicationIdentifierKeyError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
    readonly _tag: "DdfReplicationIdentifierKeyError";
} & Readonly<A>;
export declare class DdfReplicationIdentifierKeyError extends DdfReplicationIdentifierKeyError_base<{
    readonly resource: SyncResource;
    readonly keyField: string;
    readonly page: string;
    readonly index: number;
}> {
    get message(): string;
}
export interface SyncOwner {
    readonly resource: SyncResource;
    readonly key: string;
}
export interface PropertyGraph {
    readonly property: PropertyRecord;
    readonly rooms: ReadonlyArray<RoomRecord>;
    readonly media: ReadonlyArray<MediaRecord>;
}
export interface SyncRecordError {
    readonly resource: SyncResource;
    readonly key: string;
    readonly stage: SyncStage;
    readonly cause: unknown;
    readonly message: string;
}
export interface SyncCounts {
    readonly identifiers: number;
    readonly hydrated: number;
    readonly persisted: number;
    readonly failed: number;
}
export interface SyncResult<Identifier = unknown> {
    readonly resource: SyncResource;
    readonly identifiers: ReadonlyArray<Identifier>;
    readonly errors: ReadonlyArray<SyncRecordError>;
    readonly counts: SyncCounts;
    readonly nextWatermark: string | null;
}
declare const DdfReplicationIdentifierError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
    readonly _tag: "DdfReplicationIdentifierError";
} & Readonly<A>;
export declare class DdfReplicationIdentifierError extends DdfReplicationIdentifierError_base<{
    readonly resource: SyncResource;
    readonly keyName: string;
    readonly index: number;
}> {
    get message(): string;
}
export interface BaseSyncOptions {
    readonly mode?: SyncMode;
    readonly since?: string;
    readonly destinationId?: number;
    readonly concurrency?: number;
    readonly query?: ReplicationQuery;
}
export interface PropertySyncSink<SinkError = never> {
    readonly upsertPropertyGraph?: (graph: PropertyGraph) => Effect.Effect<void, SinkError>;
    readonly saveWatermark?: (resource: "Property", watermark: string) => Effect.Effect<void, SinkError>;
    readonly markMissingPropertiesInactive?: (keys: ReadonlyArray<string>) => Effect.Effect<void, SinkError>;
    readonly deleteOpenHousesForListings?: (listings: ReadonlyArray<OpenHouseListingScope>) => Effect.Effect<void, SinkError>;
}
export interface MemberSyncSink<SinkError = never> {
    readonly upsertMemberWithMedia?: (member: MemberRecord, media: ReadonlyArray<MediaRecord>) => Effect.Effect<void, SinkError>;
    readonly upsertSocialMedia?: (socialMedia: SocialMedia, owner: SyncOwner) => Effect.Effect<void, SinkError>;
    readonly saveWatermark?: (resource: "Member", watermark: string) => Effect.Effect<void, SinkError>;
    readonly markMissingMembersInactive?: (keys: ReadonlyArray<string>) => Effect.Effect<void, SinkError>;
}
export interface OfficeSyncSink<SinkError = never> {
    readonly upsertOfficeWithMedia?: (office: OfficeRecord, media: ReadonlyArray<MediaRecord>) => Effect.Effect<void, SinkError>;
    readonly upsertSocialMedia?: (socialMedia: SocialMedia, owner: SyncOwner) => Effect.Effect<void, SinkError>;
    readonly saveWatermark?: (resource: "Office", watermark: string) => Effect.Effect<void, SinkError>;
    readonly markMissingOfficesInactive?: (keys: ReadonlyArray<string>) => Effect.Effect<void, SinkError>;
}
export interface OpenHouseSyncSink<SinkError = never> {
    readonly upsertOpenHouse?: (openHouse: OpenHouseRecord) => Effect.Effect<void, SinkError>;
    readonly saveWatermark?: (resource: "OpenHouse", watermark: string) => Effect.Effect<void, SinkError>;
}
export interface OpenHouseListingScope {
    readonly listingKey: string;
    readonly listingId: string | null;
}
export interface OpenHouseDateWindow {
    readonly startDate: string;
    readonly endDate?: string;
}
export interface PropertySyncOptions<SinkError = never> extends BaseSyncOptions {
    readonly sink?: PropertySyncSink<SinkError>;
    /**
     * Applied after property hydration because replication identifiers do not expose ListAORKey.
     * Skipped hydrated properties are logged and counted in `crea_ddf_sync_skipped_total`.
     */
    readonly includeProperty?: (property: PropertyRecord) => boolean;
}
export interface MemberSyncOptions<SinkError = never> extends BaseSyncOptions {
    readonly sink?: MemberSyncSink<SinkError>;
    readonly includeMember?: (member: MemberRecord) => boolean;
}
export interface OfficeSyncOptions<SinkError = never> extends BaseSyncOptions {
    readonly sink?: OfficeSyncSink<SinkError>;
    readonly includeOffice?: (office: OfficeRecord) => boolean;
}
export interface OpenHouseSyncOptions<SinkError = never> {
    readonly query?: ODataListQuery;
    readonly concurrency?: number;
    readonly sink?: OpenHouseSyncSink<SinkError>;
    readonly listingScopes?: ReadonlyArray<OpenHouseListingScope>;
    readonly dateWindow?: OpenHouseDateWindow;
    readonly listingChunkSize?: number;
}
export interface MasterListDiff {
    readonly localKeys: ReadonlyArray<string>;
    readonly masterKeys: ReadonlyArray<string>;
    readonly missingLocalKeys: ReadonlyArray<string>;
    readonly newMasterKeys: ReadonlyArray<string>;
}
export declare const syncProperties: <SinkError = never>(options?: PropertySyncOptions<SinkError> | undefined) => Effect.Effect<{
    resource: string;
    identifiers: {
        readonly ListingKey: string;
        readonly ModificationTimestamp?: DateTime.Utc | null | undefined;
    }[];
    errors: SyncRecordError[];
    counts: SyncCounts;
    nextWatermark: string | null;
}, import("./watermark.js").DdfWatermarkError | DdfHttpError, DdfHttp>;
export declare const syncMembers: <SinkError = never>(options?: MemberSyncOptions<SinkError> | undefined) => Effect.Effect<{
    resource: string;
    identifiers: {
        readonly MemberKey: string;
        readonly ModificationTimestamp?: DateTime.Utc | null | undefined;
    }[];
    errors: SyncRecordError[];
    counts: SyncCounts;
    nextWatermark: string | null;
}, import("./watermark.js").DdfWatermarkError | DdfHttpError, DdfHttp>;
export declare const syncOffices: <SinkError = never>(options?: OfficeSyncOptions<SinkError> | undefined) => Effect.Effect<{
    resource: string;
    identifiers: {
        readonly OfficeKey: string;
        readonly ModificationTimestamp?: DateTime.Utc | null | undefined;
    }[];
    errors: SyncRecordError[];
    counts: SyncCounts;
    nextWatermark: string | null;
}, import("./watermark.js").DdfWatermarkError | DdfHttpError, DdfHttp>;
export declare const syncOpenHouses: <SinkError = never>(options?: OpenHouseSyncOptions<SinkError> | undefined) => Effect.Effect<{
    resource: string;
    identifiers: never[];
    errors: SyncRecordError[];
    counts: SyncCounts;
    nextWatermark: string | null;
}, import("./client.js").DdfInvalidODataQueryError, DdfHttp>;
export declare const getPropertyMasterList: (options?: Pick<PropertySyncOptions<never>, "destinationId" | "query"> | undefined) => Effect.Effect<{
    readonly ListingKey: string;
    readonly ModificationTimestamp?: DateTime.Utc | null | undefined;
}[], DdfReplicationIdentifierKeyError | DdfHttpError, DdfHttp>;
export declare const diffLocalKeysAgainstMasterList: (localKeys: ReadonlyArray<string>, masterKeys: ReadonlyArray<string>) => MasterListDiff;
export declare const pruneMissingProperties: <SinkError = never>(localKeys: readonly string[], options?: Pick<PropertySyncOptions<SinkError>, "destinationId" | "query" | "sink"> | undefined) => Effect.Effect<MasterListDiff, SinkError | DdfReplicationIdentifierError | DdfReplicationIdentifierKeyError | DdfHttpError, DdfHttp>;
export declare const getMemberMasterList: (options?: Pick<MemberSyncOptions<never>, "destinationId" | "query"> | undefined) => Effect.Effect<{
    readonly MemberKey: string;
    readonly ModificationTimestamp?: DateTime.Utc | null | undefined;
}[], DdfReplicationIdentifierKeyError | DdfHttpError, DdfHttp>;
export declare const getOfficeMasterList: (options?: Pick<OfficeSyncOptions<never>, "destinationId" | "query"> | undefined) => Effect.Effect<{
    readonly OfficeKey: string;
    readonly ModificationTimestamp?: DateTime.Utc | null | undefined;
}[], DdfReplicationIdentifierKeyError | DdfHttpError, DdfHttp>;
export declare const pruneMissingMembers: <SinkError = never>(localKeys: readonly string[], options?: Pick<MemberSyncOptions<SinkError>, "destinationId" | "query" | "sink"> | undefined) => Effect.Effect<MasterListDiff, SinkError | DdfReplicationIdentifierError | DdfReplicationIdentifierKeyError | DdfHttpError, DdfHttp>;
export declare const pruneMissingOffices: <SinkError = never>(localKeys: readonly string[], options?: Pick<OfficeSyncOptions<SinkError>, "destinationId" | "query" | "sink"> | undefined) => Effect.Effect<MasterListDiff, SinkError | DdfReplicationIdentifierError | DdfReplicationIdentifierKeyError | DdfHttpError, DdfHttp>;
export {};
//# sourceMappingURL=sync.d.ts.map