import { TablesRelationalConfig } from "drizzle-orm";
import { PostgresJsDatabase, PostgresJsTransaction } from "drizzle-orm/postgres-js";
import { DbOrTx, GenericEventBase, GenericEventsTable, GenericProjectionsTable, InputOf } from "./schemaHelpers";
import { ObjectWithOnlyStringOrNumberValuesOrArrayValues } from "./utils";
import { PgInsertValue, PgUpdateSetSource } from "drizzle-orm/pg-core";
export type EventClient<EventType extends string = any, Events extends GenericEventBase<EventType> = any, J extends Record<string, unknown> = any, K extends TablesRelationalConfig = any, Db extends PostgresJsDatabase<any> = any> = {
    readonly saveEvent: (eventInput: InputOf<Events>, tx?: PostgresJsTransaction<J, K>) => Promise<Events & {
        type: EventType;
    }>;
    readonly saveEvents: <T extends InputOf<Events>>(eventInputs: T[], tx?: DbOrTx<Db>) => Promise<(Events & {
        type: EventType;
    })[]>;
    readonly getLatestEvent: (eventType: EventType, options?: EventQueryOptions<EventType, Events>) => Promise<Events & {
        type: EventType;
    }>;
    readonly getEventStream: <T extends EventType>(eventTypes: T[], options?: EventQueryOptions<T, Events & {
        type: T;
    }>) => Promise<(Events & {
        type: T;
    })[]>;
    readonly getEventStreams: <T extends EventType>(streams: {
        eventTypes: T[];
        options?: EventQueryOptions<T, Events & {
            type: T;
        }>;
    }[]) => Promise<(Events & {
        type: T;
    })[]>;
    readonly saveProjection: (params: {
        type: string;
        id: string;
        data: Record<string, unknown>;
        latestEventId: string;
        forceUpdate?: boolean;
    } & PgInsertValue<GenericProjectionsTable> & PgUpdateSetSource<GenericProjectionsTable>) => Promise<{
        id: string;
        data: unknown;
        type: string;
        latestEventId: string;
        status: "created" | "updated" | "skipped";
    }>;
    readonly forceUpdateProjection: (params: Parameters<EventClient['saveProjection']>[0]) => Promise<{
        id: string;
        data: unknown;
        type: string;
        latestEventId: string;
        status: "created" | "updated" | "skipped";
    }>;
    readonly conditionalUpdateProjection: (params: Parameters<EventClient['saveProjection']>[0]) => Promise<{
        id: string;
        data: unknown;
        type: string;
        latestEventId: string;
        status: "created" | "updated" | "skipped";
    }>;
    readonly getProjection: <T>(params: {
        type: string;
        id: string;
    }) => Promise<{
        data: T;
        latestEventId: string;
    } | undefined>;
    readonly queryProjections: <T extends {
        asJson: () => Promise<Record<string, unknown>>;
    }>(params: {
        type: string;
        data?: Partial<Awaited<ReturnType<T['asJson']>>>;
    }) => Promise<{
        data: Awaited<ReturnType<T['asJson']>>;
        latestEventId: string;
    }[]>;
    readonly saveEventWithStreamValidation: (eventInput: InputOf<Events>, latestEventId: string, streams: StreamDefinition<EventType, Events>[]) => Promise<Events & {
        type: EventType;
    }>;
};
/** This is a utility type that helps to get type safety and autocomplete for the data field in the query options. */
type EventQueryOptions<T extends string, E extends GenericEventBase<T>, D extends DbOrTx<PostgresJsDatabase<any>> = DbOrTx<PostgresJsDatabase<any>>> = {
    /** The id of the event after which to query. */
    after?: string;
    /** The data to filter the events by. If an array is provided, the events will be filtered as if
     * any one of the values in the array matches. Only string and number values are supported.
     */
    data?: Partial<ObjectWithOnlyStringOrNumberValuesOrArrayValues<E["data"]>>;
    tx?: D;
};
type StreamDefinition<T extends string, E extends GenericEventBase<T>> = {
    types: T[];
    identifier: Partial<ObjectWithOnlyStringOrNumberValuesOrArrayValues<E["data"]>>;
};
export declare function createEventClient<EventType extends string, Events extends GenericEventBase<EventType>, J extends Record<string, unknown>, K extends TablesRelationalConfig, Db extends PostgresJsDatabase<Record<string, any>>>(db: DbOrTx<Db>, events: GenericEventsTable, projections: GenericProjectionsTable, ulidGenerator?: import("ulidx").ULIDFactory): {
    readonly saveEvent: (eventInput: InputOf<Events>, tx?: PostgresJsTransaction<J, K>) => Promise<Events & {
        type: EventType;
    }>;
    readonly saveEvents: <T extends InputOf<Events>>(eventInputs: T[], tx?: DbOrTx<Db>) => Promise<(Events & {
        type: EventType;
    })[]>;
    readonly getLatestEvent: (eventType: EventType, options?: EventQueryOptions<EventType, Events>) => Promise<Events & {
        type: EventType;
    }>;
    readonly getEventStream: <T extends EventType>(eventTypes: T[], options?: EventQueryOptions<T, Events & {
        type: T;
    }>) => Promise<(Events & {
        type: T;
    })[]>;
    readonly getEventStreams: <T extends EventType>(streams: {
        eventTypes: T[];
        options?: EventQueryOptions<T, Events & {
            type: T;
        }>;
    }[]) => Promise<(Events & {
        type: T;
    })[]>;
    /**
     * Save a projection to the database. If the projection already exists,
     * it will be updated as long as the incoming latestEventId
     * is greater than the current latestEventId. If the projection
     * does not exist, it will be created. A projection will be returned
     * regardless of whether it was updated or created, but the
     * `updated` field will be false if the projection already exists and
     * the incoming latestEventId was not greater than the current
     * latestEventId.
     */
    readonly saveProjection: (params: {
        type: string;
        id: string;
        data: Record<string, unknown>;
        latestEventId: string;
        forceUpdate?: boolean;
    } & PgInsertValue<GenericProjectionsTable> & PgUpdateSetSource<GenericProjectionsTable>) => Promise<{
        status: "created" | "updated" | "skipped";
        type: string;
        id: string;
        data: unknown;
        latestEventId: string;
    }>;
    readonly forceUpdateProjection: (params: Parameters<EventClient["saveProjection"]>[0]) => Promise<{
        status: "created" | "updated" | "skipped";
        type: string;
        id: string;
        data: unknown;
        latestEventId: string;
    }>;
    readonly conditionalUpdateProjection: (params: Parameters<EventClient["saveProjection"]>[0]) => Promise<{
        status: "created" | "updated" | "skipped";
        type: string;
        id: string;
        data: unknown;
        latestEventId: string;
    }>;
    readonly getProjection: <T>(params: {
        type: string;
        id: string;
    }) => Promise<{
        data: T;
        latestEventId: string;
    } | undefined>;
    readonly queryProjections: <T extends {
        asJson: () => Promise<Record<string, unknown>>;
    }>(params: {
        type: string;
        data?: Partial<Awaited<ReturnType<T["asJson"]>>>;
    }) => Promise<{
        data: Awaited<ReturnType<T["asJson"]>>;
        latestEventId: string;
    }[]>;
    readonly saveEventWithStreamValidation: (eventInput: InputOf<Events>, latestEventId: string, streams: StreamDefinition<EventType, Events>[]) => Promise<Events & {
        type: EventType;
    }>;
};
export {};