import type { CapabilityContext } from "./context.js";
import type { Database } from "./database.js";
import type { DataSourceHandle } from "./notion-as-code/database.js";
import type { NotionAsCodeSchema } from "./notion-as-code/intents.js";
import type { AppsSchemaForSchema } from "./notion-as-code/schema.js";
import { type PacerEntry } from "./pacer.js";
import type { DatabaseSchema, PropertyConfiguration, TextProperty, TitleProperty } from "./schema.js";
import type { Cover, HandlerOptions, Icon, NormalizedSchedule, PeopleValue, PlaceValue, RelationValue, Schedule, TextValue } from "./types.js";
type KeyProperty = TitleProperty | TextProperty;
/** Names of title or rich-text properties in a database schema. */
export type KeyPropertyName<S extends DatabaseSchema> = Extract<{
    [P in keyof S]: S[P] extends KeyProperty ? P : never;
}[keyof S], string>;
type PropertyValue<T extends PropertyConfiguration> = T extends {
    type: "people";
} ? PeopleValue : T extends {
    type: "place";
} ? PlaceValue : T extends {
    type: "relation";
} ? RelationValue : TextValue;
type SyncPropertyName<S extends DatabaseSchema> = Extract<keyof S, string>;
/**
 * Collect unknown property names across the whole inferred change union before checking it.
 * Otherwise a valid subset properties object could structurally hide an invalid sibling row.
 */
type SyncUnknownPropertyNames<AllowedPropertyNames extends string, Change> = Change extends {
    type: "upsert";
    properties: infer Properties extends object;
} ? Exclude<keyof Properties, AllowedPropertyNames> : never;
/** Require at least one key while keeping all other keys optional. */
type AtLeastOne<T extends object> = Partial<T> & {
    [RequiredKey in keyof T]-?: Required<Pick<T, RequiredKey>>;
}[keyof T];
type SyncUpsertProperties<S extends DatabaseSchema, PrimaryKey extends KeyPropertyName<S>> = AtLeastOne<{
    [P in Exclude<SyncPropertyName<S>, PrimaryKey>]: PropertyValue<S[P]>;
}>;
type ExactSyncHandlerResult<AllowedPropertyNames extends string, Result extends {
    changes: readonly unknown[];
}> = Result & {
    changes: [SyncUnknownPropertyNames<AllowedPropertyNames, Result["changes"][number]>] extends [
        never
    ] ? Result["changes"] : never;
};
export type SyncMode = "replace" | "incremental";
/** Upsert one or more known non-primary-key properties; the key is supplied separately. */
export type SyncChangeUpsert<S extends DatabaseSchema, PrimaryKey extends KeyPropertyName<S>> = {
    type: "upsert";
    key: string;
    properties: SyncUpsertProperties<S, PrimaryKey>;
    upstreamUpdatedAt?: string;
    icon?: Icon;
    cover?: Cover;
    pageContentMarkdown?: string;
};
export type SyncChangeDelete = {
    type: "delete";
    key: string;
};
export type SyncChange<S extends DatabaseSchema, PrimaryKey extends KeyPropertyName<S>> = SyncChangeUpsert<S, PrimaryKey> | SyncChangeDelete;
export type SyncHandlerResult<S extends DatabaseSchema, PrimaryKey extends KeyPropertyName<S>, State> = {
    changes: SyncChange<S, PrimaryKey>[];
    hasMore?: boolean;
    nextState?: State;
};
export type SyncConfiguration<S extends DatabaseSchema, PrimaryKey extends KeyPropertyName<S>, State, Result extends SyncHandlerResult<S, PrimaryKey, State> = SyncHandlerResult<S, PrimaryKey, State>> = {
    database: Database<S>;
    primaryKey: PrimaryKey;
    mode?: SyncMode;
    schedule?: Schedule;
    handler: (state: State | undefined, context: CapabilityContext) => Promise<SyncHandlerResult<NoInfer<S>, NoInfer<PrimaryKey>, State> & ExactSyncHandlerResult<Exclude<SyncPropertyName<NoInfer<S>>, NoInfer<PrimaryKey>>, Result>>;
};
/** Configuration for a sync backed by a Notion-as-Code data source. */
export type DataSourceSyncConfiguration<Schema extends NotionAsCodeSchema, PrimaryKey extends KeyPropertyName<AppsSchemaForSchema<Schema>>, State, Result extends SyncHandlerResult<AppsSchemaForSchema<Schema>, PrimaryKey, State> = SyncHandlerResult<AppsSchemaForSchema<Schema>, PrimaryKey, State>> = Omit<SyncConfiguration<AppsSchemaForSchema<Schema>, PrimaryKey, State, Result>, "database"> & {
    dataSource: DataSourceHandle<Schema>;
};
export type SyncRuntimeContext = {
    state?: unknown;
    userContext?: unknown;
    pacers?: Record<string, PacerEntry>;
};
type SyncDefinitionConfig = {
    database: Database;
    primaryKeyProperty: string;
    mode?: SyncMode;
    schedule?: NormalizedSchedule;
};
export type SyncRunResult = {
    changes: unknown[];
    hasMore: boolean;
    nextUserContext?: unknown;
    nextPacerStates: Record<string, PacerEntry>;
};
export type Sync<S extends DatabaseSchema = DatabaseSchema, PrimaryKey extends KeyPropertyName<S> = KeyPropertyName<S>, State = unknown> = {
    _tag: "sync";
    config: SyncDefinitionConfig;
    handler: (context?: SyncRuntimeContext, options?: HandlerOptions) => Promise<SyncRunResult>;
};
export type SyncChangeFor<Definition extends Sync> = Definition extends Sync<infer S, infer PrimaryKey> ? SyncChange<S, PrimaryKey> : never;
export type SyncStateFor<Definition extends Sync> = Definition extends Sync<infer _S, infer _PrimaryKey, infer State> ? State : never;
/** Create a database sync. Default-export it from a sync file. */
export declare function createSync<const S extends DatabaseSchema, const PrimaryKey extends KeyPropertyName<S>, State = unknown, const Result extends SyncHandlerResult<S, PrimaryKey, State> = SyncHandlerResult<S, PrimaryKey, State>>(configuration: SyncConfiguration<S, PrimaryKey, State, Result>): Sync<S, PrimaryKey, State>;
/** Create a sync backed by a Notion-as-Code data source. */
export declare function sync<const Schema extends NotionAsCodeSchema, const PrimaryKey extends KeyPropertyName<AppsSchemaForSchema<Schema>>, State = unknown, const Result extends SyncHandlerResult<AppsSchemaForSchema<Schema>, PrimaryKey, State> = SyncHandlerResult<AppsSchemaForSchema<Schema>, PrimaryKey, State>>(configuration: DataSourceSyncConfiguration<Schema, PrimaryKey, State, Result>): Sync<AppsSchemaForSchema<Schema>, PrimaryKey, State>;
export {};
//# sourceMappingURL=sync.d.ts.map