import ClickHouse from '@posthog/clickhouse';
import { CacheOptions, Properties } from '@posthog/plugin-scaffold';
import { Pool as GenericPool } from 'generic-pool';
import { StatsD } from 'hot-shots';
import Redis from 'ioredis';
import { ProducerRecord } from 'kafkajs';
import { DateTime } from 'luxon';
import { Pool, PoolClient, QueryConfig, QueryResult, QueryResultRow } from 'pg';
import { Action, ActionEventPair, ClickHouseEvent, ClickhouseGroup, ClickHousePerson, ClickHousePersonDistinctId, Cohort, CohortPeople, Database, DeadLetterQueueEvent, Element, Event, EventDefinitionType, GroupTypeToColumnIndex, Hook, Person, PersonDistinctId, PluginConfig, PluginLogEntry, PluginLogEntrySource, PluginLogEntryType, PostgresSessionRecordingEvent, PropertyDefinitionType, RawOrganization, SessionRecordingEvent, Team, TeamId } from '../../types';
import { UUID, UUIDT } from '../utils';
import { KafkaProducerWrapper } from './kafka-producer-wrapper';
import { PostgresLogsWrapper } from './postgres-logs-wrapper';
export interface LogEntryPayload {
    pluginConfig: PluginConfig;
    source: PluginLogEntrySource;
    type: PluginLogEntryType;
    message: string;
    instanceId: UUID;
    timestamp?: string | null;
}
export interface ParsedLogEntry {
    id: string;
    team_id: number;
    plugin_id: number;
    plugin_config_id: number;
    timestamp: string;
    source: PluginLogEntrySource;
    type: PluginLogEntryType;
    message: string;
    instance_id: string;
}
export interface CreateUserPayload {
    uuid: UUIDT;
    password: string;
    first_name: string;
    last_name: string;
    email: string;
    distinct_id: string;
    is_staff: boolean;
    is_active: boolean;
    date_joined: Date;
    events_column_config: Record<string, string> | null;
    organization_id?: RawOrganization['id'];
}
export interface CreatePersonalApiKeyPayload {
    id: string;
    user_id: number;
    label: string;
    value: string;
    created_at: Date;
}
export declare class DB {
    postgres: Pool;
    redisPool: GenericPool<Redis.Redis>;
    kafkaProducer?: KafkaProducerWrapper;
    clickhouse?: ClickHouse;
    statsd: StatsD | undefined;
    postgresLogsWrapper: PostgresLogsWrapper;
    MAX_GROUP_TYPES_PER_TEAM: number;
    constructor(postgres: Pool, redisPool: GenericPool<Redis.Redis>, kafkaProducer: KafkaProducerWrapper | undefined, clickhouse: ClickHouse | undefined, statsd: StatsD | undefined);
    postgresQuery<R extends QueryResultRow = any, I extends any[] = any[]>(queryTextOrConfig: string | QueryConfig<I>, values: I | undefined, tag: string): Promise<QueryResult<R>>;
    postgresTransaction<ReturnType extends any>(transaction: (client: PoolClient) => Promise<ReturnType>): Promise<ReturnType>;
    clickhouseQuery(query: string, options?: ClickHouse.QueryOptions): Promise<ClickHouse.QueryResult<Record<string, any>>>;
    redisGet(key: string, defaultValue: unknown, options?: CacheOptions): Promise<unknown>;
    redisSet(key: string, value: unknown, ttlSeconds?: number, options?: CacheOptions): Promise<void>;
    redisIncr(key: string): Promise<number>;
    redisExpire(key: string, ttlSeconds: number): Promise<boolean>;
    redisLPush(key: string, value: unknown, options?: CacheOptions): Promise<number>;
    redisLRange(key: string, startIndex: number, endIndex: number): Promise<string[]>;
    redisLLen(key: string): Promise<number>;
    redisBRPop(key1: string, key2: string): Promise<[string, string]>;
    redisLRem(key: string, count: number, elementKey: string): Promise<number>;
    redisLPop(key: string, count: number): Promise<string[]>;
    fetchPersons(database?: Database.Postgres): Promise<Person[]>;
    fetchPersons(database: Database.ClickHouse): Promise<ClickHousePerson[]>;
    fetchPerson(teamId: number, distinctId: string, client?: PoolClient, forUpdate?: boolean): Promise<Person | undefined>;
    createPerson(createdAt: DateTime, properties: Properties, propertiesOnce: Properties, teamId: number, isUserId: number | null, isIdentified: boolean, uuid: string, distinctIds?: string[]): Promise<Person>;
    updatePerson(person: Person, update: Partial<Person>, client: PoolClient): Promise<ProducerRecord[]>;
    updatePerson(person: Person, update: Partial<Person>): Promise<Person>;
    private getPropertyLastUpdatedAtDateTimeOrEpoch;
    private getPropertiesLastOperationOrSet;
    private updatePropertiesLastOperation;
    private updatePersonPropertiesLocal;
    updatePersonProperties(teamId: number, distinctId: string, properties: Properties, propertiesOnce: Properties, timestamp: DateTime): Promise<void>;
    deletePerson(person: Person, client: PoolClient): Promise<ProducerRecord[]>;
    fetchDistinctIds(person: Person, database?: Database.Postgres): Promise<PersonDistinctId[]>;
    fetchDistinctIds(person: Person, database: Database.ClickHouse): Promise<ClickHousePersonDistinctId[]>;
    fetchDistinctIdValues(person: Person, database?: Database): Promise<string[]>;
    addDistinctId(person: Person, distinctId: string): Promise<void>;
    addDistinctIdPooled(client: PoolClient | Pool, person: Person, distinctId: string): Promise<ProducerRecord | void>;
    moveDistinctIds(source: Person, target: Person): Promise<ProducerRecord[]>;
    createCohort(cohort: Partial<Cohort>): Promise<Cohort>;
    doesPersonBelongToCohort(cohortId: number, person: Person, teamId: Team['id']): Promise<boolean>;
    addPersonToCohort(cohortId: number, personId: Person['id']): Promise<CohortPeople>;
    fetchEvents(): Promise<Event[] | ClickHouseEvent[]>;
    fetchDeadLetterQueueEvents(): Promise<DeadLetterQueueEvent[]>;
    fetchSessionRecordingEvents(): Promise<PostgresSessionRecordingEvent[] | SessionRecordingEvent[]>;
    fetchElements(event?: Event): Promise<Element[]>;
    createElementGroup(elements: Element[], teamId: number): Promise<string>;
    fetchPluginLogEntries(): Promise<PluginLogEntry[]>;
    queuePluginLogEntry(entry: LogEntryPayload): Promise<void>;
    batchInsertPostgresLogs(entries: ParsedLogEntry[]): Promise<void>;
    fetchEventDefinitions(): Promise<EventDefinitionType[]>;
    fetchPropertyDefinitions(): Promise<PropertyDefinitionType[]>;
    fetchAllActionsGroupedByTeam(): Promise<Record<Team['id'], Record<Action['id'], Action>>>;
    fetchAction(id: Action['id']): Promise<Action | null>;
    fetchActionMatches(): Promise<ActionEventPair[]>;
    registerActionMatch(eventId: Event['id'], actions: Action[]): Promise<void>;
    fetchOrganization(organizationId: string): Promise<RawOrganization | undefined>;
    fetchTeam(teamId: Team['id']): Promise<Team>;
    fetchInternalMetricsTeam(): Promise<Team['id'] | null>;
    fetchRelevantRestHooks(teamId: Hook['team_id'], event: Hook['event'], resourceId: Hook['resource_id']): Promise<Hook[]>;
    deleteRestHook(hookId: Hook['id']): Promise<void>;
    createUser({ uuid, password, first_name, last_name, email, distinct_id, is_staff, is_active, date_joined, events_column_config, organization_id, }: CreateUserPayload): Promise<QueryResult>;
    createPersonalApiKey({ id, user_id, label, value, created_at, }: CreatePersonalApiKeyPayload): Promise<QueryResult>;
    fetchGroupTypes(teamId: TeamId): Promise<GroupTypeToColumnIndex>;
    insertGroupType(teamId: TeamId, groupType: string, index: number): Promise<[number | null, boolean]>;
    upsertGroup(teamId: TeamId, groupTypeIndex: number, groupKey: string, properties: Properties): Promise<void>;
    fetchGroups(): Promise<ClickhouseGroup[]>;
}