import type { DBHandlerServer, DboBuilder, PRGLIOSocket } from "../DboBuilder/DboBuilder";
import type { PostgresNotifListenManager } from "../PostgresNotifListenManager";
import type { DB } from "../Prostgles";
import { type AddTriggerParams } from "./addTrigger";
import type { AnyObject, FieldFilter, SelectParams, SyncTableInfo, TableSchema, WAL } from "prostgles-types";
import { type SubscribeOptions } from "prostgles-types";
import type { OnData } from "../DboBuilder/ViewHandler/subscribe";
import type { EventTypes } from "../Logging";
import type { ParsedTableRule } from "../PublishParser/PublishParser";
export type BasicCallback = (err?: any, res?: any) => void;
export type SyncParams = {
    socket_id: string;
    sid: string | undefined;
    channel_name: string;
    table_name: string;
    table_rules?: ParsedTableRule;
    synced_field: string;
    id_fields: string[];
    batch_size: number;
    filter: object;
    params: {
        select: FieldFilter;
    };
    condition: string;
    wal?: WAL;
    throttle?: number;
    lr?: AnyObject;
    last_synced: number;
    is_syncing: boolean;
};
export type AddSyncParams = SyncTableInfo & {
    socket: PRGLIOSocket;
    table_info: TableSchema;
    table_rules: ParsedTableRule;
    allow_delete?: boolean;
    filter: object;
    params: {
        select: FieldFilter;
    };
    condition: string;
    throttle?: number;
};
export type ViewSubscriptionOptions = ({
    type: "view";
    viewName: string;
    definition: string;
} | {
    type: "table";
    viewName?: undefined;
    definition?: undefined;
}) & {
    relatedTables: (Pick<AddTriggerParams, "condition" | "tracked_columns"> & {
        tableName: string;
        tableNameEscaped: string;
    })[];
};
export type SubscriptionParams = {
    socket_id?: string;
    channel_name: string;
    /**
     * If this is a view then all related tables will be added triggers
     * */
    viewOptions?: ViewSubscriptionOptions;
    parentSubParams: Omit<SubscriptionParams, "parentSubParams"> | undefined;
    table_info: TableSchema;
    table_rules?: ParsedTableRule;
    filter: object;
    selectParams: SelectParams;
    subscribeOptions: SubscribeOptions;
    onData?: OnData;
    socket: PRGLIOSocket | undefined;
    lastPushed: number;
    /**
     * Prevent out of order pushes
     */
    pushRequestedVersion: number;
    isPushing?: boolean;
    reRun?: boolean;
    is_throttling?: any;
    is_ready?: boolean;
};
export type Subscription = Pick<SubscriptionParams, "selectParams" | "subscribeOptions" | "is_throttling" | "lastPushed" | "pushRequestedVersion" | "isPushing" | "reRun" | "channel_name" | "is_ready" | "onData" | "socket" | "socket_id" | "table_info" | "filter" | "table_rules"> & {
    triggers: [AddTriggerParams, ...AddTriggerParams[]];
};
export type TableTriggerInfo = {
    table_condition_id: number;
    condition: string;
    hash: string;
    columnInfo: {
        join_condition: string;
        tracked_columns: Record<string, number>;
    } | null;
};
export type PubSubManagerTriggers = Map<string, Map<number, TableTriggerInfo>>;
/**
 * Used to facilitate table subscribe and sync
 */
export declare class PubSubManager {
    static create: (dboBuilder: DboBuilder) => Promise<PubSubManager | undefined>;
    appInfoWasInserted: boolean;
    get appId(): `${string}-${string}-${string}-${string}-${string}`;
    get db(): DB;
    get dbo(): DBHandlerServer;
    dboBuilder: DboBuilder;
    /**
     * Triggers used for sync/sub that reflect prostgles.app_triggers.
     * Updated through refreshTriggers()
     */
    _triggers: PubSubManagerTriggers;
    sockets: Record<string, PRGLIOSocket>;
    subs: Subscription[];
    syncs: SyncParams[];
    readonly socketChannelPreffix: string;
    postgresNotifListenManager?: PostgresNotifListenManager;
    private constructor();
    appCheckFrequencyMS: number;
    appCheck?: ReturnType<typeof setInterval>;
    destroyed: boolean;
    destroy: () => Promise<void>;
    getIsDestroyed: () => boolean;
    appChecking: boolean;
    checkedListenerTableCond?: string[];
    initialiseEventTriggers: () => Promise<boolean>;
    getClientSubs({ channel_name, onData, socket_id, }: Pick<Subscription, "onData" | "socket_id" | "channel_name">): Subscription[];
    getTriggerSubs(table_name: string, condition: string): Subscription[];
    removeSubscription: (channelName: string, subInfo: {
        type: "local";
        onData: OnData;
    } | {
        type: "ws";
        socket: PRGLIOSocket;
    }) => void;
    getSyncs(table_name: string, condition: string): SyncParams[];
    notifListener: (data: {
        payload: string;
    }) => Promise<void>;
    getTriggerInfo: (tableName: string) => {
        subs: Subscription[];
        syncs: SyncParams[];
        table_condition_id: number;
        condition: string;
        hash: string;
        columnInfo: {
            join_condition: string;
            tracked_columns: Record<string, number>;
        } | null;
    }[] | undefined;
    getActiveTriggers: (tableName: string) => {
        subs: Subscription[];
        syncs: SyncParams[];
        table_condition_id: number;
        condition: string;
        hash: string;
        columnInfo: {
            join_condition: string;
            tracked_columns: Record<string, number>;
        } | null;
    }[];
    getAllActiveTriggers: () => {
        tableName: string;
        subs: Subscription[];
        syncs: SyncParams[];
        table_condition_id: number;
        condition: string;
        hash: string;
        columnInfo: {
            join_condition: string;
            tracked_columns: Record<string, number>;
        } | null;
    }[];
    getSubData: (sub: Subscription) => Promise<{
        data: AnyObject[];
        err?: undefined;
    } | {
        err: string | any[] | AnyObject;
        data?: undefined;
    }>;
    pushSubData: (sub: Subscription, err?: any) => Promise<true | undefined>;
    upsertSocket(socket: PRGLIOSocket | undefined): void;
    get connectedSocketIds(): string[];
    _log: (params: EventTypes.Sync | EventTypes.SyncOrSub) => void | Promise<void> | undefined;
    syncTimeout?: ReturnType<typeof setTimeout>;
    syncData: (sync: SyncParams, clientData: import("../SyncReplication").ClientExpressData | undefined, source: "client" | "trigger") => Promise<void>;
    addSync: (syncParams: AddSyncParams) => Promise<{
        channelName: string;
    }>;
    addSub: (subscriptionParams: Omit<import("./addSub").AddSubscriptionParams, "channel_name" | "parentSubParams">) => Promise<import("prostgles-types").SubscriptionChannels & {
        sendFirstData: import("../SchemaWatch/SchemaWatch").VoidFunction | undefined;
    }>;
    getActiveListeners: () => {
        table_name: string;
        condition: string;
    }[];
    /**
     * Sync triggers with database
     *  */
    refreshTriggers: () => Promise<void>;
    /** Throttle trigger deletes */
    deletingOrphanedTriggers: {
        tableNames: Set<string>;
        timeout: NodeJS.Timeout;
    } | undefined;
    deleteOrphanedTriggers: (latestTableNames: Set<string>) => void;
    addingTrigger: any;
    addTriggerPool?: Record<string, string[]>;
    addTrigger: (params: AddTriggerParams, viewOptions: ViewSubscriptionOptions | undefined, socket: PRGLIOSocket | undefined) => Promise<import("prostgles-types").TryCatchResult<{
        tableName: string;
        condition: string;
        conditionHash: string;
        relatedViewName: string | null;
        relatedViewDef: string | null;
        columnsInfo: {
            join_condition: string;
            tracked_columns: Record<string, number>;
        } | null;
    }>>;
}
//# sourceMappingURL=PubSubManager.d.ts.map