prostgles-server 4.2.2 → 4.2.4

package/dist/my.d.ts

@@ -0,0 +1,1655 @@
+// Generated by dts-bundle-generator v9.2.1
+
+import { Express as Express$1, NextFunction, Request, Response } from 'express';
+import * as pg from 'pg';
+import CursorType from 'pg-cursor';
+import { 
+	ALLOWED_CONTENT_TYPE, ALLOWED_EXTENSION, ClientSchema, ColumnInfo, DBSchema, DbJoinMaker, DeleteParams, EXISTS_KEY, FieldFilter, FileColumnConfig, 
+	FullFilter, InsertParams, JSONB, Method, PG_COLUMN_UDT_DATA_TYPE, RawJoinPath, SQLHandler, SQLOptions, Select, SelectParams, SocketSQLStreamServer, SubscribeParams, TableHandler, TableInfo, TableInfo as TInfo, UpdateParams, ValidatedColumnInfo, ViewHandler, WAL 
+} from 'prostgles-types';
+type AnyObject = Record<string, any>;
+import { Server } from 'socket.io';
+import * as stream from 'stream';
+
+export type Awaitable<T> = T | Promise<T>;
+export type AuthSocketSchema = {
+	user?: AnyObject;
+	register?: boolean;
+	login?: boolean;
+	logout?: boolean;
+	pathGuard?: boolean;
+};
+export type ExpressReq = Request;
+export type ExpressRes = Response;
+export type LoginClientInfo = {
+	ip_address: string;
+	ip_address_remote: string | undefined;
+	x_real_ip: string | undefined;
+	user_agent: string | undefined;
+};
+export type BasicSession = {
+	/** Must be hard to bruteforce */
+	sid: string;
+	/** UNIX millisecond timestamp */
+	expires: number;
+	/** On expired */
+	onExpiration: "redirect" | "show_error";
+};
+export type AuthClientRequest = {
+	socket: PRGLIOSocket;
+} | {
+	httpReq: ExpressReq;
+};
+export type UserLike = {
+	id: string;
+	type: string;
+	[key: string]: any;
+};
+export type SessionUser<ServerUser extends UserLike = UserLike, ClientUser extends AnyObject = AnyObject> = {
+	/**
+	 * This user will be available in all serverside prostgles options
+	 * id and type values will be available in the prostgles.user session variable in postgres
+	 * */
+	user: ServerUser;
+	/**
+	 * Controls which fields from user are available in postgres session variable
+	 */
+	sessionFields?: FieldFilter<ServerUser>;
+	/**
+	 * User data sent to the authenticated client
+	 */
+	clientUser: ClientUser;
+};
+export type AuthResult<SU = SessionUser> = SU & {
+	sid: string;
+} | {
+	user?: undefined;
+	clientUser?: undefined;
+	sid?: string;
+} | undefined;
+export type AuthRequestParams<S, SUser extends SessionUser> = {
+	db: DB$1;
+	dbo: DBOFullyTyped<S>;
+	getUser: () => Promise<AuthResult<SUser>>;
+};
+export type ParsedJoinPath = {
+	table: string;
+	on: Record<string, string>[];
+};
+export type GetQueryArgs = {
+	allColumns: ColumnInfo[];
+	allowedFields: string[];
+	args: any[];
+	tableAlias?: string;
+	ctidField?: string;
+};
+export type FieldSpec = {
+	name: string;
+	type: "column" | "computed";
+	/**
+	 * allowedFields passed for multicol functions (e.g.: $rowhash)
+	 */
+	getQuery: (params: Omit<GetQueryArgs, "args">) => string;
+};
+declare class TableHandler$1 extends ViewHandler$1 {
+	constructor(db: DB$1, tableOrViewInfo: TableSchema, dboBuilder: DboBuilder, tx?: {
+		t: any
+		dbTX: TableHandlers;
+	}, joinPaths?: JoinPaths);
+	getFinalDBtx: (localParams: LocalParams | undefined) => TableHandlers | undefined;
+	getFinalDbo: (localParams: LocalParams | undefined) => TableHandlers;
+	parseUpdateRules: (filter: Filter, newData: AnyObject, params?: UpdateParams | undefined, tableRules?: TableRule | undefined, localParams?: LocalParams | undefined) => Promise<{
+		fields: string[];
+		validateRow?: ValidateRow | undefined;
+		finalUpdateFilter: AnyObject;
+		forcedData?: AnyObject | undefined;
+		forcedFilter?: AnyObject | undefined;
+		returningFields: FieldFilter;
+		filterFields?: FieldFilter | undefined;
+	}>;
+	update: (filter: Filter, _newData: AnyObject, params?: UpdateParams | undefined, tableRules?: TableRule | undefined, localParams?: LocalParams | undefined) => Promise<void | AnyObject>;
+	updateBatch: (updates: [
+		Filter,
+		AnyObject
+	][], params?: UpdateParams | undefined, tableRules?: TableRule | undefined, localParams?: LocalParams | undefined) => Promise<any>;
+	validateNewData({ row, forcedData, allowedFields, tableRules, fixIssues }: ValidatedParams): {
+		data: AnyObject;
+		allowedCols: string[];
+	};
+	insert(rowOrRows: (AnyObject | AnyObject[]), param2?: InsertParams, param3_unused?: undefined, tableRules?: TableRule, _localParams?: LocalParams): Promise<any | any[] | boolean>;
+	prepareReturning: (returning: Select | undefined, allowedFields: string[]) => Promise<SelectItem[]>;
+	makeReturnQuery(items?: SelectItem[]): string;
+	delete(filter?: Filter, params?: DeleteParams, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<any>;
+	remove(filter: Filter, params?: UpdateParams, param3_unused?: undefined, tableRules?: TableRule, localParams?: LocalParams): Promise<any>;
+	upsert(filter: Filter, newData: AnyObject, params?: UpdateParams, table_rules?: TableRule, localParams?: LocalParams): Promise<any>;
+	sync(filter: Filter, params: {
+		select?: FieldFilter;
+	}, param3_unused: undefined, table_rules: TableRule, localParams: LocalParams): Promise<{
+		channelName: string | undefined;
+		id_fields: string[];
+		synced_field: string;
+	}>;
+}
+export type ClientInfo = {
+	socketId: string;
+	sid: string | undefined;
+};
+export type Graph = {
+	[key: string]: {
+		[key: string]: number;
+	};
+};
+declare class ColSet {
+	opts: {
+		columns: ColumnInfo[];
+		tableName: string;
+		colNames: string[];
+	};
+	constructor(columns: ColumnInfo[], tableName: string);
+	private getRow;
+	getInsertQuery(data: AnyObject[], allowedCols: string[], dbTx: DBHandlerServer, validate: ValidateRowBasic | undefined, localParams: LocalParams | undefined): Promise<string>;
+	getUpdateQuery(data: AnyObject | AnyObject[], allowedCols: string[], dbTx: DBHandlerServer, validate: ValidateRowBasic | undefined, localParams: LocalParams | undefined): Promise<string>;
+}
+export type JoinPaths = {
+	t1: string;
+	t2: string;
+	path: string[];
+}[];
+declare class ViewHandler$1 {
+	db: DB$1;
+	name: string;
+	escapedName: string;
+	columns: TableSchema["columns"];
+	columnsForTypes: ColumnInfo[];
+	column_names: string[];
+	tableOrViewInfo: TableSchema;
+	colSet: ColSet;
+	tsColumnDefs: string[];
+	joins: Join[];
+	joinGraph?: Graph;
+	joinPaths?: JoinPaths;
+	dboBuilder: DboBuilder;
+	tx?: {
+		t: any
+		dbTX: TableHandlers;
+	};
+	get dbHandler(): DB$1 | any
+	is_view: boolean;
+	filterDef: string;
+	is_media: boolean;
+	constructor(db: DB$1, tableOrViewInfo: TableSchema, dboBuilder: DboBuilder, tx?: {
+		t: any
+		dbTX: TableHandlers;
+	}, joinPaths?: JoinPaths);
+	_log: ({ command, data, localParams }: Pick<TableEvent, "command" | "data" | "localParams">) => Promise<void> | undefined;
+	getRowHashSelect(allowedFields: FieldFilter, alias?: string, tableAlias?: string): string;
+	validateViewRules: (args: {
+		fields?: FieldFilter | undefined;
+		filterFields?: FieldFilter | undefined;
+		returningFields?: FieldFilter | undefined;
+		forcedFilter?: AnyObject | undefined;
+		dynamicFields?: {
+			filter: import("prostgles-types").FullFilter<AnyObject, void>;
+			fields: FieldFilter<AnyObject>;
+		}[] | undefined;
+		rule: "update" | "insert" | "delete" | "select";
+	}) => Promise<boolean>;
+	getShortestJoin(table1: string, table2: string, startAlias: number, isInner?: boolean): {
+		query: string;
+		toOne: boolean;
+	};
+	checkFilter(filter: any): void;
+	getInfo: (lang?: string | undefined, param2?: any, param3?: any, tableRules?: TableRule | undefined, localParams?: LocalParams | undefined) => Promise<import("prostgles-types").TableInfo>;
+	getColumns: (lang?: string | undefined, params?: {
+		rule: "update";
+		filter: AnyObject;
+		data: AnyObject;
+	} | undefined, _param3?: undefined, tableRules?: TableRule | undefined, localParams?: LocalParams | undefined) => Promise<import("prostgles-types").ValidatedColumnInfo[]>;
+	getValidatedRules(tableRules?: TableRule, localParams?: LocalParams): ValidatedTableRules;
+	find: (filter?: Filter | undefined, selectParams?: SelectParams | undefined, _?: undefined, tableRules?: TableRule | undefined, localParams?: LocalParams | undefined) => Promise<any[]>;
+	findOne(filter?: Filter, selectParams?: SelectParams, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<any>;
+	subscribe(filter: Filter, params: SubscribeParams, localFuncs: LocalFuncs): Promise<{
+		unsubscribe: () => any;
+	}>;
+	subscribe(filter: Filter, params: SubscribeParams, localFuncs: undefined, table_rules: TableRule | undefined, localParams: LocalParams): Promise<string>;
+	subscribeOne(filter: Filter, params: SubscribeParams, localFunc: (item: AnyObject) => any): Promise<{
+		unsubscribe: () => any;
+	}>;
+	subscribeOne(filter: Filter, params: SubscribeParams, localFunc: undefined, table_rules: TableRule, localParams: LocalParams): Promise<string>;
+	count(_filter?: Filter, selectParams?: SelectParams, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<number>;
+	size(_filter?: Filter, selectParams?: SelectParams, param3_unused?: undefined, table_rules?: TableRule, localParams?: LocalParams): Promise<string>;
+	getAllowedSelectFields(selectParams: FieldFilter | undefined, allowed_cols: FieldFilter, allow_empty?: boolean): string[];
+	/**
+	 * Parses group or simple filter
+	 */
+	prepareWhere: (params: {
+		filter?: Filter | undefined;
+		select?: SelectItem[] | undefined;
+		forcedFilter?: AnyObject | undefined;
+		filterFields?: FieldFilter | undefined;
+		addWhere?: boolean | undefined;
+		tableAlias?: string | undefined;
+		localParams: LocalParams | undefined;
+		tableRule: TableRule | undefined;
+	}) => Promise<{
+		condition: string;
+		where: string;
+		filter: AnyObject;
+		exists: ExistsFilterConfig[];
+	}>;
+	prepareLimitQuery(limit: number | null | undefined, p: ValidatedTableRules): number | null;
+	prepareOffsetQuery(offset?: number): number;
+	intersectColumns(allowedFields: FieldFilter, dissallowedFields: FieldFilter, fixIssues?: boolean): string[];
+	/**
+	* Prepare and validate field object:
+	* @example ({ item_id: 1 }, { user_id: 32 }) => { item_id: 1, user_id: 32 }
+	* OR
+	* ({ a: 1 }, { b: 32 }, ["c", "d"]) => throw "a field is not allowed"
+	* @param {Object} obj - initial data
+	* @param {Object} forcedData - set/override property
+	* @param {string[]} allowed_cols - allowed columns (excluding forcedData) from table rules
+	*/
+	prepareFieldValues(obj: AnyObject | undefined, forcedData: AnyObject | undefined, allowed_cols: FieldFilter | undefined, removeDisallowedColumns?: boolean): AnyObject;
+	parseFieldFilter(fieldParams?: FieldFilter, allow_empty?: boolean, allowed_cols?: string[]): string[];
+}
+export type OnData = (items: AnyObject[]) => any;
+export type LocalFuncs = {
+	onData: OnData;
+	onError?: (error: any) => void;
+} | OnData;
+export type ClientSyncInfo = Partial<{
+	c_fr: AnyObject;
+	c_lr: AnyObject;
+	/**
+	 * PG count is ussually string due to bigint
+	 */
+	c_count: number | string;
+}>;
+export type ClientExpressData = ClientSyncInfo & {
+	data?: AnyObject[];
+	deleted?: AnyObject[];
+};
+export type BasicCallback = (err?: any, res?: any) => void;
+export type SyncParams = {
+	socket_id: string;
+	channel_name: string;
+	table_name: string;
+	table_rules?: TableRule;
+	synced_field: string;
+	allow_delete: boolean;
+	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 = {
+	socket: PRGLIOSocket;
+	table_info: TableInfo$1;
+	table_rules: TableRule;
+	synced_field: string;
+	allow_delete?: boolean;
+	id_fields: string[];
+	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: {
+		tableName: string;
+		tableNameEscaped: string;
+		condition: string;
+	}[];
+};
+export type SubscriptionParams = Pick<SubscribeParams, "throttle" | "throttleOpts"> & {
+	socket_id?: string;
+	channel_name: string;
+	/**
+	 * If this is a view then an array with all related tables will be
+	 * */
+	viewOptions?: ViewSubscriptionOptions;
+	parentSubParams: Omit<SubscriptionParams, "parentSubParams"> | undefined;
+	table_info: TableOrViewInfo;
+	table_rules?: TableRule;
+	filter: object;
+	params: SelectParams;
+	localFuncs?: LocalFuncs;
+	socket: PRGLIOSocket | undefined;
+	last_throttled: number;
+	is_throttling?: any;
+	is_ready?: boolean;
+};
+export type PubSubManagerOptions = {
+	dboBuilder: DboBuilder;
+	wsChannelNamePrefix?: string;
+	pgChannelName?: string;
+	onSchemaChange?: (event: {
+		command: string;
+		query: string;
+	}) => void;
+};
+export type Subscription = Pick<SubscriptionParams, "throttle" | "is_throttling" | "last_throttled" | "throttleOpts" | "channel_name" | "is_ready" | "localFuncs" | "socket" | "socket_id" | "table_info" | "filter" | "params" | "table_rules"> & {
+	triggers: {
+		table_name: string;
+		condition: string;
+		is_related: boolean;
+	}[];
+};
+declare class PubSubManager {
+	static DELIMITER: "|$prstgls$|";
+	static SCHEMA_ALTERING_QUERIES: readonly [
+		"CREATE TABLE",
+		"ALTER TABLE",
+		"DROP TABLE",
+		"CREATE VIEW",
+		"DROP VIEW",
+		"ALTER VIEW",
+		"CREATE TABLE AS",
+		"SELECT INTO",
+		"REVOKE",
+		"GRANT",
+		"CREATE POLICY",
+		"DROP POLICY"
+	];
+	static EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID: "prostgles internal query that should be excluded from schema watch ";
+	static canCreate: (db: DB$1) => Promise<{
+		canExecute: boolean;
+		isSuperUs: boolean;
+		yes: boolean;
+	}>;
+	static create: (options: PubSubManagerOptions) => Promise<PubSubManager | undefined>;
+	get db(): DB$1;
+	get dbo(): DBHandlerServer;
+	dboBuilder: DboBuilder;
+	_triggers?: Record<string, string[]>;
+	sockets: AnyObject;
+	subs: Subscription[];
+	syncs: SyncParams[];
+	socketChannelPreffix: string;
+	onSchemaChange?: ((event: {
+		command: string;
+		query: string;
+	}) => void);
+	postgresNotifListenManager?: PostgresNotifListenManager;
+	private constructor();
+	NOTIF_TYPE: {
+		readonly data: "data_has_changed";
+		readonly data_trigger_change: "data_watch_triggers_have_changed";
+		readonly schema: "schema_has_changed";
+	};
+	NOTIF_CHANNEL: {
+		preffix: "prostgles_";
+		getFull: (appID?: string) => string;
+	};
+	/**
+	 * Used facilitate concurrent prostgles connections to the same database
+	 */
+	appID?: string;
+	appCheckFrequencyMS: number;
+	appCheck?: ReturnType<typeof setInterval>;
+	destroyed: boolean;
+	destroy: () => void;
+	canContinue: () => boolean;
+	appChecking: boolean;
+	checkedListenerTableCond?: string[];
+	init: () => Promise<PubSubManager | undefined>;
+	initialiseEventTriggers: () => Promise<boolean>;
+	isReady(): any;
+	getClientSubs(client: Pick<Subscription, "localFuncs" | "socket_id" | "channel_name">): Subscription[];
+	getTriggerSubs(table_name: string, condition: string): Subscription[];
+	removeLocalSub(channelName: string, localFuncs: LocalFuncs): void;
+	getSyncs(table_name: string, condition: string): SyncParams[];
+	notifListener: (data: {
+		payload: string;
+	}) => Promise<void>;
+	getSubData: (sub: Subscription) => Promise<{
+		data: any[];
+		err?: undefined;
+	} | {
+		data?: undefined;
+		err: any;
+	}>;
+	pushSubData: (sub: Subscription, err?: any) => Promise<unknown>;
+	upsertSocket(socket: PRGLIOSocket | undefined): void;
+	get connectedSocketIds(): string[];
+	_log: (params: EventTypes.Sync) => Promise<void> | undefined;
+	syncTimeout?: ReturnType<typeof setTimeout>;
+	syncData: (sync: SyncParams, clientData: ClientExpressData | undefined, source: "client" | "trigger") => Promise<void>;
+	addSync: (syncParams: AddSyncParams) => Promise<string | undefined>;
+	addSub: (subscriptionParams: Omit<Pick<SubscribeParams, "throttle" | "throttleOpts"> & {
+		socket_id?: string | undefined;
+		channel_name: string;
+		/**
+		 * If this is a view then an array with all related tables will be
+		 * */
+		viewOptions?: ViewSubscriptionOptions | undefined;
+		parentSubParams: Omit<SubscriptionParams, "parentSubParams"> | undefined;
+		table_info: TableOrViewInfo;
+		table_rules?: TableRule | undefined;
+		filter: object;
+		params: SelectParams;
+		localFuncs?: LocalFuncs | undefined;
+		socket: PRGLIOSocket | undefined;
+		last_throttled: number;
+		is_throttling?: any;
+		is_ready?: boolean | undefined;
+	} & {
+		condition: string;
+	}, "channel_name" | "parentSubParams">) => Promise<import("prostgles-types").SubscriptionChannels>;
+	getActiveListeners: () => {
+		table_name: string;
+		condition: string;
+	}[];
+	/**
+	 * Sync triggers with database
+	 *  */
+	refreshTriggers: () => Promise<void>;
+	addingTrigger: any;
+	addTriggerPool?: Record<string, string[]>;
+	addTrigger(params: {
+		table_name: string;
+		condition: string;
+	}, viewOptions: ViewSubscriptionOptions | undefined, socket: PRGLIOSocket | undefined): Promise<({
+		tbl: string;
+		cond: string;
+	} & {
+		error?: undefined;
+		duration: number;
+	}) | (Partial<Record<"tbl" | "cond", undefined>> & {
+		error: unknown;
+		duration: number;
+	})>;
+}
+export type TableSchemaColumn = ColumnInfo & {
+	privileges: Partial<Record<"INSERT" | "REFERENCES" | "SELECT" | "UPDATE", true>>;
+};
+export type TableSchema = {
+	schema: string;
+	name: string;
+	escaped_identifier: string;
+	oid: number;
+	comment: string;
+	columns: TableSchemaColumn[];
+	is_view: boolean;
+	view_definition: string | null;
+	parent_tables: string[];
+	privileges: {
+		insert: boolean;
+		select: boolean;
+		update: boolean;
+		delete: boolean;
+	};
+	/** Cannot add triggers to hyperTables */
+	isHyperTable?: boolean;
+};
+export type TxCB<TH = DbTxTableHandlers> = {
+	(t: TH & Pick<DBHandlerServer, "sql">, _t: pgPromise.ITask<{}>): (any | void);
+};
+export type TX<TH = TableHandlers> = {
+	(t: TxCB<TH>): Promise<(any | void)>;
+};
+export type TableHandlers = {
+	[key: string]: Partial<TableHandler$1> | TableHandler$1;
+};
+export type DbTxTableHandlers = {
+	[key: string]: Omit<Partial<TableHandler$1>, "dbTx"> | Omit<TableHandler$1, "dbTx">;
+};
+export type DBHandlerServer<TH = TableHandlers> = TH & Partial<DbJoinMaker> & {
+	sql?: SQLHandler;
+} & {
+	tx?: TX<TH>;
+};
+export type TableInfo$1 = TInfo & {
+	schema: string;
+	name: string;
+	oid: number;
+	comment: string;
+	columns: ColumnInfo[];
+};
+export type ViewInfo = TableInfo$1 & {
+	parent_tables: string[];
+};
+export type TableOrViewInfo = TableInfo$1 & ViewInfo & {
+	is_view: boolean;
+};
+export type PRGLIOSocket = {
+	readonly id: string;
+	readonly handshake: {
+		query?: Record<string, string | string[] | undefined>;
+		/**
+		 * IP Address
+		 */
+		address: string;
+		headers?: AnyObject & {
+			cookie?: string;
+		};
+		auth?: Record<string, any>;
+	};
+	readonly on: (channel: string, params: any, cb?: (err: any, res?: any) => void) => any;
+	readonly emit: (channel: string, message?: any, cb?: BasicCallback) => any;
+	readonly once: (channel: string, cb: (_data: any, cb: BasicCallback) => void) => void;
+	readonly removeAllListeners: (channel: string) => void;
+	readonly disconnect: () => void;
+	readonly request: {
+		url?: string;
+		connection: {
+			remoteAddress?: string;
+		};
+	};
+	/** Used for session caching */
+	__prglCache?: {
+		session: BasicSession;
+		user: UserLike;
+		clientUser: AnyObject;
+	};
+	_user?: AnyObject;
+	/** Used for publish error caching */
+	prostgles?: AnyObject;
+};
+export type LocalParams = {
+	httpReq?: ExpressReq;
+	socket?: PRGLIOSocket;
+	func?: () => any;
+	isRemoteRequest?: {
+		user?: UserLike | undefined;
+	};
+	testRule?: boolean;
+	tableAlias?: string;
+	tx?: {
+		dbTX: TableHandlers;
+		t: any
+	};
+	returnQuery?: boolean | "noRLS" | "where-condition";
+	returnNewQuery?: boolean;
+	/** Used for count/size queries */
+	bypassLimit?: boolean;
+	nestedInsert?: {
+		depth: number;
+		previousData: AnyObject;
+		previousTable: string;
+		referencingColumn?: string;
+	};
+};
+export type Filter = AnyObject | {
+	$and: Filter[];
+} | {
+	$or: Filter[];
+};
+export type JoinInfo = {
+	/**
+	 * If true then all joins involve unique columns and the result is a 1 to 1 join
+	 */
+	expectOne?: boolean;
+	paths: {
+		/**
+		 * The table that JOIN ON columns refer to.
+		 * columns in index = 1 refer to this table. index = 0 columns refer to previous JoinInfo.table
+		 */
+		table: string;
+		/**
+		 * Source and target JOIN ON column groups for each existing constraint
+		 * Each inner array group will be combined with AND and outer arrays with OR to allow multiple references to the same table
+		 * e.g.:    [[source_table_column: string, table_column: string]]
+		 */
+		on: [
+			string,
+			string
+		][][];
+		/**
+		 * Source table name
+		 */
+		source: string;
+		/**
+		 * Target table name
+		 */
+		target: string;
+	}[];
+};
+export type CommonTableRules = {
+	/**
+	 * True by default. Allows clients to get column information on any columns that are allowed in (select, insert, update) field rules.
+	 */
+	getColumns?: PublishAllOrNothing;
+	/**
+	 * True by default. Allows clients to get table information (oid, comment, label, has_media).
+	 */
+	getInfo?: PublishAllOrNothing;
+};
+export type ValidatedTableRules = CommonTableRules & {
+	allColumns: FieldSpec[];
+	select: {
+		fields: string[];
+		orderByFields: string[];
+		filterFields: string[];
+		forcedFilter: any;
+		maxLimit: number | null;
+	};
+	update: {
+		fields: string[];
+		returningFields: string[];
+		filterFields: string[];
+		forcedFilter: any;
+		forcedData: any;
+	};
+	insert: {
+		fields: string[];
+		returningFields: string[];
+		forcedData: any;
+	};
+	delete: {
+		filterFields: string[];
+		forcedFilter: any;
+		returningFields: string[];
+	};
+};
+export type ExistsFilterConfig = {
+	existType: EXISTS_KEY;
+	/**
+	 * Target table filter. target table is the last table from tables
+	 */
+	targetTableFilter: Filter;
+} & ({
+	isJoined: true;
+	/**
+	 * list of join tables in their order
+	 * If table path starts with "**" then get shortest join to first table
+	 * e.g.: "**.users" means finding the shortest join from root table to users table
+	 */
+	path: RawJoinPath;
+	parsedPath: ParsedJoinPath[];
+} | {
+	isJoined: false;
+	targetTable: string;
+});
+export type PublishMethods<S = void, SUser extends SessionUser = SessionUser> = (params: PublishParams<S, SUser>) => {
+	[key: string]: Method;
+} | Promise<{
+	[key: string]: Method;
+} | null>;
+export type Awaitable$1<T> = T | Promise<T>;
+export type Request$1 = {
+	socket?: any;
+	httpReq?: any;
+};
+export type DboTable = Request$1 & {
+	tableName: string;
+	localParams: LocalParams;
+};
+export type DboTableCommand = Request$1 & DboTable & {
+	command: string;
+	localParams: LocalParams;
+};
+export type SelectRequestData = {
+	filter: object;
+	params: SelectParams;
+};
+export type ValidateRowArgs<R = AnyObject, DBX = DBHandlerServer> = {
+	row: R;
+	dbx: DBX;
+	localParams: LocalParams;
+};
+export type ValidateUpdateRowArgs<U = Partial<AnyObject>, F = Filter, DBX = DBHandlerServer> = {
+	update: U;
+	filter: F;
+	dbx: DBX;
+	localParams: LocalParams;
+};
+export type ValidateRow<R extends AnyObject = AnyObject, S = void> = (args: ValidateRowArgs<R, DBOFullyTyped<S>>) => R | Promise<R>;
+export type PostValidateRow<R extends AnyObject = AnyObject, S = void> = (args: ValidateRowArgs<R, DBOFullyTyped<S>>) => void | Promise<void>;
+export type ValidateRowBasic = (args: ValidateRowArgs) => AnyObject | Promise<AnyObject>;
+export type ValidateUpdateRow<R extends AnyObject = AnyObject, S extends DBSchema | void = void> = (args: ValidateUpdateRowArgs<Partial<R>, FullFilter<R, S>, DBOFullyTyped<S>>) => Partial<R> | Promise<Partial<R>>;
+export type SelectRule<Cols extends AnyObject = AnyObject, S extends DBSchema | void = void> = {
+	/**
+	 * Fields allowed to be selected.
+	 * Tip: Use false to exclude field
+	 */
+	fields: FieldFilter<Cols>;
+	/**
+	 * Fields allowed to sorted
+	 * Defaults to the "fields". Use empty array/object to disallow sorting
+	 */
+	orderByFields?: FieldFilter<Cols>;
+	/**
+	 * The maximum number of rows a user can get in a select query. null by default. Unless a null or higher limit is specified 100 rows will be returned by the default
+	 */
+	maxLimit?: number | null;
+	/**
+	 * Filter added to every query (e.g. user_id) to restrict access
+	 */
+	forcedFilter?: FullFilter<Cols, S>;
+	/**
+	 * Fields user can filter by
+	 * */
+	filterFields?: FieldFilter<Cols>;
+	/**
+	 * Validation logic to check/update data for each request
+	 */
+	validate?(args: SelectRequestData): SelectRequestData | Promise<SelectRequestData>;
+};
+export type CommonInsertUpdateRule<Cols extends AnyObject = AnyObject, S extends DBSchema | void = void> = {
+	/**
+	 * Filter that the new records must match or the update/insert will fail
+	 * Similar to a policy WITH CHECK clause
+	 */
+	checkFilter?: SelectRule<Cols, S>["forcedFilter"];
+	/**
+	 * Data to include and overwrite on each update/insert
+	 * These fields cannot be updated by the user
+	 */
+	forcedData?: Partial<Cols>;
+};
+export type InsertRule<Cols extends AnyObject = AnyObject, S extends DBSchema | void = void> = CommonInsertUpdateRule<Cols, S> & {
+	/**
+	 * Fields allowed to be inserted.   Tip: Use false to exclude field
+	 */
+	fields: SelectRule<Cols>["fields"];
+	/**
+	 * Fields user can view after inserting
+	 */
+	returningFields?: SelectRule<Cols>["fields"];
+	/**
+	 * Validation logic to check/update data for each request. Happens before publish rule checks (for fields, forcedData/forcedFilter)
+	 */
+	preValidate?: ValidateRow<Cols, S>;
+	/**
+	 * Validation logic to check/update data for each request. Happens after publish rule checks (for fields, forcedData/forcedFilter)
+	 */
+	validate?: ValidateRow<Cols, S>;
+	/**
+	 * Validation logic to check/update data after the insert.
+	 * Happens in the same transaction so upon throwing an error the record will be deleted (not committed)
+	 */
+	postValidate?: PostValidateRow<Required<Cols>, S>;
+	/**
+	 * If defined then only nested inserts from these tables are allowed
+	 * Direct inserts will fail
+	 */
+	allowedNestedInserts?: {
+		table: string;
+		column: string;
+	}[];
+};
+export type UpdateRule<Cols extends AnyObject = AnyObject, S extends DBSchema | void = void> = CommonInsertUpdateRule<Cols, S> & {
+	/**
+	 * Fields allowed to be updated.   Tip: Use false/0 to exclude field
+	 */
+	fields: SelectRule<Cols>["fields"];
+	/**
+	 * Row level FGAC
+	 * Used when the editable fields change based on the updated row
+	 * If specified then the fields from the first matching filter table.count({ ...filter, ...updateFilter }) > 0 will be used
+	 * If none matching then the "fields" will be used
+	 * Specify in decreasing order of specificity otherwise a more general filter will match first
+	 */
+	dynamicFields?: {
+		filter: FullFilter<Cols, S>;
+		fields: SelectRule<Cols>["fields"];
+	}[];
+	/**
+	 * Filter added to every query (e.g. user_id) to restrict access
+	 * This filter cannot be updated
+	 */
+	forcedFilter?: SelectRule<Cols, S>["forcedFilter"];
+	/**
+	 * Fields user can use to find the updates
+	 */
+	filterFields?: SelectRule<Cols>["fields"];
+	/**
+	 * Fields user can view after updating
+	 */
+	returningFields?: SelectRule<Cols>["fields"];
+	/**
+	 * Validation logic to check/update data for each request
+	 */
+	validate?: ValidateUpdateRow<Cols, S>;
+	/**
+	 * Validation logic to check/update data after the insert.
+	 * Happens in the same transaction so upon throwing an error the record will be deleted (not committed)
+	 */
+	postValidate?: PostValidateRow<Required<Cols>, S>;
+};
+export type DeleteRule<Cols extends AnyObject = AnyObject, S extends DBSchema | void = void> = {
+	/**
+	 * Filter added to every query (e.g. user_id) to restrict access
+	 */
+	forcedFilter?: SelectRule<Cols, S>["forcedFilter"];
+	/**
+	 * Fields user can filter by
+	 */
+	filterFields: FieldFilter<Cols>;
+	/**
+	 * Fields user can view after deleting
+	 */
+	returningFields?: SelectRule<Cols>["filterFields"];
+	/**
+	 * Validation logic to check/update data for each request
+	 */
+	validate?(...args: any[]): Awaitable$1<void>;
+};
+export type SyncRule<Cols extends AnyObject = AnyObject> = {
+	/**
+	 * Primary keys used in updating data
+	 */
+	id_fields: (keyof Cols)[];
+	/**
+	 * Numerical incrementing fieldname (last updated timestamp) used to sync items
+	 */
+	synced_field: keyof Cols;
+	/**
+	 * EXPERIMENTAL. Disabled by default. If true then server will attempt to delete any records missing from client.
+	 */
+	allow_delete?: boolean;
+	/**
+	 * Throttle replication transmission in milliseconds. Defaults to 100
+	 */
+	throttle?: number;
+	/**
+	 * Number of rows to send per trip. Defaults to 50
+	 */
+	batch_size?: number;
+};
+export type SubscribeRule = {
+	throttle?: number;
+};
+export type ViewRule<S extends AnyObject = AnyObject> = CommonTableRules & {
+	/**
+	 * What can be read from the table
+	 */
+	select?: SelectRule<S>;
+};
+export type TableRule<RowType extends AnyObject = AnyObject, S extends DBSchema | void = void> = ViewRule<RowType> & {
+	insert?: InsertRule<RowType, S>;
+	update?: UpdateRule<RowType, S>;
+	delete?: DeleteRule<RowType, S>;
+	sync?: SyncRule<RowType>;
+	subscribe?: SubscribeRule;
+};
+export type PublishViewRule<Col extends AnyObject = AnyObject, S extends DBSchema | void = void> = {
+	select?: SelectRule<Col, S> | PublishAllOrNothing;
+	getColumns?: PublishAllOrNothing;
+	getInfo?: PublishAllOrNothing;
+};
+export type PublishTableRule<Col extends AnyObject = AnyObject, S extends DBSchema | void = void> = PublishViewRule<Col, S> & {
+	insert?: InsertRule<Col, S> | PublishAllOrNothing;
+	update?: UpdateRule<Col, S> | PublishAllOrNothing;
+	delete?: DeleteRule<Col, S> | PublishAllOrNothing;
+	sync?: SyncRule<Col>;
+	subscribe?: SubscribeRule | PublishAllOrNothing;
+};
+export type ParsedPublishTable = {
+	select?: SelectRule;
+	getColumns?: true;
+	getInfo?: true;
+	insert?: InsertRule;
+	update?: UpdateRule;
+	delete?: DeleteRule;
+	sync?: SyncRule;
+	subscribe?: SubscribeRule;
+	subscribeOne?: SubscribeRule;
+};
+export type DbTableInfo = {
+	name: string;
+	info: TableOrViewInfo;
+	columns: TableSchemaColumn[];
+};
+export type PublishParams<S = void, SUser extends SessionUser = SessionUser> = {
+	sid?: string;
+	dbo: DBOFullyTyped<S>;
+	db: DB$1;
+	user?: SUser["user"];
+	socket: PRGLIOSocket;
+	tables: DbTableInfo[];
+};
+export type PublishAllOrNothing = true | "*" | false | null;
+export type PublishObject = {
+	[table_name: string]: (PublishTableRule | PublishViewRule | PublishAllOrNothing);
+};
+export type PublishedResult<Schema = void> = PublishAllOrNothing | PublishFullyTyped<Schema>;
+export type Publish<Schema = void, SUser extends SessionUser = SessionUser> = PublishedResult<Schema> | ((params: PublishParams<Schema, SUser>) => Awaitable$1<PublishedResult<Schema>>);
+declare class PublishParser {
+	publish: any;
+	publishMethods?: PublishMethods<void, SessionUser> | undefined;
+	publishRawSQL?: any;
+	dbo: DBHandlerServer;
+	db: DB$1;
+	prostgles: Prostgles;
+	constructor(publish: any, publishMethods: PublishMethods<void, SessionUser> | undefined, publishRawSQL: any, dbo: DBHandlerServer, db: DB$1, prostgles: Prostgles);
+	getPublishParams(localParams: LocalParams, clientInfo?: AuthResult): Promise<PublishParams>;
+	getAllowedMethods(reqInfo: Pick<LocalParams, "httpReq" | "socket">, userData?: AuthResult): Promise<{
+		[key: string]: Method;
+	}>;
+	/**
+	 * Parses the first level of publish. (If false then nothing if * then all tables and views)
+	 * @param socket
+	 * @param user
+	 */
+	getPublish(localParams: LocalParams, clientInfo?: AuthResult): Promise<PublishObject>;
+	getValidatedRequestRuleWusr({ tableName, command, localParams }: DboTableCommand): Promise<TableRule>;
+	getValidatedRequestRule({ tableName, command, localParams }: DboTableCommand, clientInfo?: AuthResult): Promise<TableRule>;
+	getTableRules(args: DboTable, clientInfo?: AuthResult): Promise<ParsedPublishTable | undefined>;
+	getTableRulesWithoutFileTable: (args_0: DboTable, args_1?: AuthResult, args_2?: PublishObject | undefined) => Promise<ParsedPublishTable | undefined>;
+	getSchemaFromPublish: (args_0: ({
+		socket: PRGLIOSocket;
+		httpReq?: undefined;
+	} | {
+		httpReq: ExpressReq;
+		socket?: undefined;
+	}) & {
+		userData: AuthResult;
+	}) => Promise<{
+		schema: import("prostgles-types").TableSchemaForClient;
+		tables: import("prostgles-types").DBSchemaTable[];
+	}>;
+}
+export type DbConnection = string | pg$1.IConnectionParameters<pg$1.IClient>;
+export type DbConnectionOpts = pg$1.IDefaults;
+export type PGP = pgPromise.IMain<{}, pg$1.IClient>;
+export type DB = pgPromise.IDatabase<{}, pg$1.IClient>;
+export type OnInitReason = {
+	type: "schema change";
+	query: string;
+	command: string;
+} | {
+	type: "init" | "prgl.restart" | "prgl.update" | "TableConfig";
+};
+export type OnReadyParamsCommon = {
+	db: DB;
+	tables: DbTableInfo[];
+	reason: OnInitReason;
+};
+export type OnReadyParamsBasic = OnReadyParamsCommon & {
+	dbo: DBHandlerServer;
+};
+export type OnReadyParams<S> = OnReadyParamsCommon & {
+	dbo: DBOFullyTyped<S>;
+};
+export type OnReadyCallback<S = void> = (params: OnReadyParams<S>) => any;
+export type OnReadyCallbackBasic = (params: OnReadyParamsBasic) => any;
+export type InitResult = {
+	db: DBOFullyTyped;
+	_db: DB;
+	pgp: PGP;
+	io?: any;
+	destroy: () => Promise<boolean>;
+	/**
+	 * Generated database public schema TS types for all tables and views
+	 */
+	getTSSchema: () => string;
+	update: (newOpts: Pick<ProstglesInitOptions, "fileTable" | "restApi" | "tableConfig">) => Promise<void>;
+	restart: () => Promise<InitResult>;
+};
+export type ColExtraInfo = {
+	min?: string | number;
+	max?: string | number;
+	hint?: string;
+};
+export type I18N_Config<LANG_IDS> = {
+	[lang_id in keyof LANG_IDS]: string;
+};
+export type BaseTableDefinition<LANG_IDS = AnyObject> = {
+	info?: {
+		label?: string | I18N_Config<LANG_IDS>;
+	};
+	dropIfExistsCascade?: boolean;
+	dropIfExists?: boolean;
+	hooks?: {
+		/**
+		 * Hook used to run custom logic before inserting a row.
+		 * The returned row must satisfy the table schema
+		 */
+		getPreInsertRow?: (args: ValidateRowArgs) => Promise<{
+			row: AnyObject;
+			onInserted: Promise<void>;
+		}>;
+	};
+	triggers?: {
+		[triggerName: string]: {
+			/**
+			 * Use "before" when you need to change the data before the action
+			 */
+			type: "before" | "after" | "instead of";
+			actions: ("insert" | "update" | "delete")[];
+			forEach: "statement" | "row";
+			/**
+			 * @example
+			 * DECLARE
+				x_rec record;
+			  BEGIN
+				  raise notice '=operation: % =', TG_OP;
+				  IF (TG_OP = 'UPDATE' OR TG_OP = 'DELETE') THEN
+					  FOR x_rec IN SELECT * FROM old_table LOOP
+						  raise notice 'OLD: %', x_rec;
+					  END loop;
+				  END IF;
+				  IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
+					  FOR x_rec IN SELECT * FROM new_table LOOP
+						  raise notice 'NEW: %', x_rec;
+					  END loop;
+				  END IF;
+	  
+				  RETURN NULL;
+			  END;
+			 */
+			query: string;
+		};
+	};
+};
+export type LookupTableDefinition<LANG_IDS> = {
+	isLookupTable: {
+		values: {
+			[id_value: string]: {} | {
+				[lang_id in keyof LANG_IDS]: string;
+			};
+		};
+	};
+};
+export type BaseColumn<LANG_IDS> = {
+	/**
+	 * Will add these values to .getColumns() result
+	 */
+	info?: ColExtraInfo;
+	label?: string | Partial<{
+		[lang_id in keyof LANG_IDS]: string;
+	}>;
+};
+export type SQLDefColumn = {
+	/**
+	 * Raw sql statement used in creating/adding column
+	 */
+	sqlDefinition?: string;
+};
+export type BaseColumnTypes = {
+	defaultValue?: any;
+	nullable?: boolean;
+};
+export type TextColumn = BaseColumnTypes & {
+	isText: true;
+	/**
+	 * Value will be trimmed before update/insert
+	 */
+	trimmed?: boolean;
+	/**
+	 * Value will be lower cased before update/insert
+	 */
+	lowerCased?: boolean;
+};
+export type JSONBColumnDef = (BaseColumnTypes & {}) & ({
+	jsonbSchema: JSONB.JSONBSchema;
+	jsonbSchemaType?: undefined;
+} | {
+	jsonbSchema?: undefined;
+	jsonbSchemaType: JSONB.ObjectType["type"];
+});
+/**
+ * Allows referencing media to this table.
+ * Requires this table to have a primary key AND a valid fileTable config
+ */
+export type MediaColumn = ({
+	name: string;
+	label?: string;
+	files: "one" | "many";
+} & ({
+	/**
+	 * https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/accept
+	 */
+	allowedContentType?: Record<Partial<("audio/*" | "video/*" | "image/*" | "text/*" | ALLOWED_CONTENT_TYPE)>, 1>;
+} | {
+	allowedExtensions?: Record<Partial<ALLOWED_EXTENSION>, 1>;
+}));
+export type ReferencedColumn = {
+	/**
+	 * Will create a lookup table that this column will reference
+	 */
+	references?: BaseColumnTypes & {
+		tableName: string;
+		/**
+		 * Defaults to id
+		 */
+		columnName?: string;
+	};
+};
+export type JoinDef = {
+	sourceTable: string;
+	targetTable: string;
+	on: JoinInfo["paths"][number]["on"];
+};
+/**
+ * Used in specifying a join path to a table. This column name can then be used in select
+ */
+export type NamedJoinColumn = {
+	label?: string;
+	joinDef: JoinDef[];
+};
+export type Enum<T extends string | number = any> = {
+	enum: T[] | readonly T[];
+	nullable?: boolean;
+	defaultValue?: T;
+};
+export type ColumnConfig<LANG_IDS = {
+	en: 1;
+}> = string | StrictUnion<NamedJoinColumn | MediaColumn | (BaseColumn<LANG_IDS> & (SQLDefColumn | ReferencedColumn | TextColumn | JSONBColumnDef | Enum))>;
+export type UnionKeys<T> = T extends T ? keyof T : never;
+export type StrictUnionHelper<T, TAll> = T extends any ? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>> : never;
+export type StrictUnion<T> = StrictUnionHelper<T, T>;
+declare const CONSTRAINT_TYPES: readonly [
+	"PRIMARY KEY",
+	"UNIQUE",
+	"CHECK"
+];
+export type TableDefinition<LANG_IDS> = {
+	onMount?: (params: {
+		dbo: DBHandlerServer;
+		_db: DB$1;
+	}) => Promise<void | {
+		onUnmount: () => void;
+	}>;
+	columns?: {
+		[column_name: string]: ColumnConfig<LANG_IDS>;
+	};
+	constraints?: string[] | {
+		[constraint_name: string]: string | {
+			type: typeof CONSTRAINT_TYPES[number];
+			dropIfExists?: boolean;
+			/**
+			 * E.g.:
+			 * colname
+			 * col1, col2
+			 * col1 > col3
+			 */
+			content: string;
+		};
+	};
+	/**
+	 * Similar to unique constraints but expressions are allowed inside definition
+	 */
+	replaceUniqueIndexes?: boolean;
+	indexes?: {
+		[index_name: string]: {
+			/**
+			 * If true then will drop any existing index with this name
+			 * Overrides replaceUniqueIndexes
+			 */
+			replace?: boolean;
+			/**
+			 * Causes the system to check for duplicate values in the table when the index is created (if data already exist) and each time data is added.
+			 * Attempts to insert or update data which would result in duplicate entries will generate an error.
+			 */
+			unique?: boolean;
+			/**
+			 * When this option is used, PostgreSQL will build the index without taking any locks that prevent
+			 * concurrent inserts, updates, or deletes on the table; whereas a standard index build locks out writes (but not reads) on the table until it's done.
+			 * There are several caveats to be aware of when using this option — see Building Indexes Concurrently.
+			 */
+			concurrently?: boolean;
+			/**
+			 * Table name
+			 */
+			/**
+			 * Column list
+			 * @example: col1, col2
+			 */
+			columns: string;
+			/**
+			 * Where clause without the "where"
+			 * Used to create a partial index. A partial index is an index that contains entries for only a portion of a table
+			 * Another possible application is to use WHERE with UNIQUE to enforce uniqueness over a subset of a table
+			 */
+			where?: string;
+			/**
+			 * The name of the index method to be used.
+			 * Choices are btree, hash, gist, and gin. The default method is btree.
+			 */
+			using?: "btree" | "hash" | "gist" | "gin";
+		};
+	};
+};
+export type GetPreInsertRowArgs = ValidateRowArgs & {
+	preValidate: InsertRule["preValidate"];
+	validate: InsertRule["validate"];
+};
+/**
+ * Helper utility to create lookup tables for TEXT columns
+ */
+export type TableConfig<LANG_IDS = {
+	en: 1;
+}> = {
+	[table_name: string]: BaseTableDefinition<LANG_IDS> & (TableDefinition<LANG_IDS> | LookupTableDefinition<LANG_IDS>);
+};
+declare class TableConfigurator<LANG_IDS = {
+	en: 1;
+}> {
+	instanceId: number;
+	config: TableConfig<LANG_IDS>;
+	get dbo(): DBHandlerServer;
+	get db(): DB$1;
+	prostgles: Prostgles;
+	constructor(prostgles: Prostgles);
+	destroy: () => Promise<void>;
+	tableOnMounts: Record<string, {
+		onUnmount: () => void;
+	}>;
+	setTableOnMounts: () => Promise<void>;
+	getColumnConfig: (tableName: string, colName: string) => ColumnConfig | undefined;
+	getTableInfo: (params: {
+		tableName: string;
+		lang?: string;
+	}) => TableInfo["info"] | undefined;
+	getColInfo: (params: {
+		col: string;
+		table: string;
+		lang?: string;
+	}) => (ColExtraInfo & {
+		label?: string;
+	} & Pick<ColumnInfo, "jsonbSchema">) | undefined;
+	checkColVal: (params: {
+		col: string;
+		table: string;
+		value: any;
+	}) => void;
+	getJoinInfo: (sourceTable: string, targetTable: string) => JoinInfo | undefined;
+	getPreInsertRow: (tableHandler: TableHandler$1, args: GetPreInsertRowArgs) => Promise<AnyObject>;
+	prevInitQueryHistory?: string[];
+	initialising: boolean;
+	init: () => Promise<undefined>;
+}
+declare class DBEventsManager {
+	notifies: {
+		[key: string]: {
+			socketChannel: string;
+			sockets: any[];
+			localFuncs: ((payload: string) => void)[];
+			notifMgr: PostgresNotifListenManager;
+		};
+	};
+	notice: {
+		socketChannel: string;
+		socketUnsubChannel: string;
+		sockets: any[];
+	};
+	notifManager?: PostgresNotifListenManager;
+	db_pg: DB$1;
+	pgp: PGP$1;
+	constructor(db_pg: DB$1, pgp: PGP$1);
+	private onNotif;
+	onNotice: (notice: any) => void;
+	getNotifChannelName: (channel: string) => Promise<any>;
+	addNotify(query: string, socket?: PRGLIOSocket, func?: any): Promise<{
+		socketChannel: string;
+		socketUnsubChannel: string;
+		notifChannel: string;
+		unsubscribe?: () => void;
+	}>;
+	removeNotify(channel?: string, socket?: PRGLIOSocket, func?: any): void;
+	addNotice(socket: PRGLIOSocket): {
+		socketChannel: string;
+		socketUnsubChannel: string;
+	};
+	removeNotice(socket: PRGLIOSocket): void;
+}
+export type ColConstraint = {
+	name: string;
+	table: string;
+	type: "c" | "p" | "u" | "f";
+	cols: Array<string>;
+	definition: string;
+	schema: string;
+};
+export type PGP$1 = pgPromise.IMain<{}, pg$1.IClient>;
+export type DB$1 = pgPromise.IDatabase<{}, pg$1.IClient>;
+declare const JOIN_TYPES: readonly [
+	"one-many",
+	"many-one",
+	"one-one",
+	"many-many"
+];
+export type Join = {
+	tables: [
+		string,
+		string
+	];
+	on: {
+		[key: string]: string;
+	}[];
+	type: typeof JOIN_TYPES[number];
+};
+export type Joins = Join[] | "inferred";
+export type Keywords = {
+	$and: string;
+	$or: string;
+	$not: string;
+};
+/**
+ * Allows uploading and downloading files.
+ * Currently supports only S3.
+ *
+ * @description
+ * Will create a media table that contains file metadata and urls
+ * Inserting a file into this table through prostgles will upload it to S3 and insert the relevant metadata into the media table
+ * Requesting a file from HTTP GET {fileUrlPath}/{fileId} will:
+ *  1. check auth (if provided)
+ *  2. check the permissions in publish (if provided)
+ *  3. redirect the request to the signed url (if allowed)
+ *
+ * Specifying referencedTables will:
+ *  1. create a column in that table called media
+ *  2. create a lookup table lookup_media_{referencedTable} that joins referencedTable to the media table
+ */
+export type FileTableConfig = {
+	tableName?: string;
+	/**
+	 * GET path used in serving media. defaults to /${tableName}
+	 */
+	fileServeRoute?: string;
+	cloudClient?: CloudClient;
+	localConfig?: LocalConfig;
+	/**
+	 * If defined the the files will not be deleted immediately
+	 * Instead, the "deleted" field will be updated to the current timestamp and after the day interval provided in "deleteAfterNDays" the files will be deleted
+	 * "checkIntervalMinutes" is the frequency in hours at which the files ready for deletion are deleted
+	 */
+	delayedDelete?: {
+		/**
+		 * Minimum amount of time measured in days for which the files will not be deleted after requesting delete
+		 */
+		deleteAfterNDays: number;
+		/**
+		 * How freuquently the files will be checked for deletion delay
+		 */
+		checkIntervalHours?: number;
+	};
+	expressApp: ExpressApp;
+	referencedTables?: {
+		[tableName: string]: 
+		/**
+		 * If defined then will try to create (if necessary) these columns which will reference files_table(id)
+		 * Prostgles UI will use these hints (obtained through tableHandler.getInfo())
+		 * */
+		{
+			type: "column";
+			referenceColumns: Record<string, FileColumnConfig>;
+		};
+	};
+	imageOptions?: ImageOptions;
+};
+export type ProstglesInitOptions<S = void, SUser extends SessionUser = SessionUser> = {
+	dbConnection: DbConnection;
+	dbOptions?: DbConnectionOpts;
+	tsGeneratedTypesDir?: string;
+	io?: Server;
+	publish?: Publish<S, SUser>;
+	publishMethods?: PublishMethods<S, SUser>;
+	publishRawSQL?(params: PublishParams<S, SUser>): ((boolean | "*") | Promise<(boolean | "*")>);
+	joins?: Joins;
+	schema?: Record<string, 1> | Record<string, 0>;
+	sqlFilePath?: string;
+	onReady: OnReadyCallback<S>;
+	transactions?: string | boolean;
+	wsChannelNamePrefix?: string;
+	/**
+	 * Use for connection verification. Will disconnect socket on any errors
+	 */
+	onSocketConnect?: (args: AuthRequestParams<S, SUser> & {
+		socket: PRGLIOSocket;
+	}) => void | Promise<void>;
+	onSocketDisconnect?: (args: AuthRequestParams<S, SUser> & {
+		socket: PRGLIOSocket;
+	}) => void | Promise<void>;
+	auth?: Auth<S, SUser>;
+	DEBUG_MODE?: boolean;
+	watchSchemaType?: 
+	/**
+	 * Will set database event trigger for schema changes. Requires superuser
+	 * Default
+	 */
+	"DDL_trigger"
+	/**
+	 * Will check client queries for schema changes
+	 * fallback if DDL not possible
+	 */
+	 | "prostgles_queries"
+	/**
+	 * Schema checked for changes every 'checkIntervalMillis" milliseconds
+	 */
+	 | {
+		checkIntervalMillis: number;
+	};
+	/**
+	 * If truthy then DBoGenerated.d.ts will be updated and "onReady" will be called with new schema on both client and server
+	 */
+	watchSchema?: 
+	/**
+	 * Will listen only to few events (create table/view)
+	 */
+	boolean
+	/**
+	 * Will listen to specified events (or all if "*" is specified)
+	 */
+	 | EventTriggerTagFilter
+	/**
+	 * Will only rewrite the DBoGenerated.d.ts found in tsGeneratedTypesDir
+	 * This is meant to be used in development when server restarts on file change
+	 */
+	 | "hotReloadMode"
+	/**
+	 * Function called when schema changes. Nothing else triggered
+	 */
+	 | ((event: {
+		command: string;
+		query: string;
+	}) => void);
+	keywords?: Keywords;
+	onNotice?: (notice: AnyObject, message?: string) => void;
+	fileTable?: FileTableConfig;
+	restApi?: RestApiConfig;
+	/**
+	 * Creates tables and provides UI labels, autocomplete and hints for a given json structure
+	 */
+	tableConfig?: TableConfig;
+	tableConfigMigrations?: {
+		/**
+		 * If false then prostgles won't start on any tableConfig error
+		 * true by default
+		 */
+		silentFail?: boolean;
+		version: number;
+		/** Table that will contain the schema version number and the tableConfig
+		 * Defaults to schema_version
+		*/
+		versionTableName?: string;
+		/**
+		 * Script run before tableConfig is loaded IF an older schema_version is present
+		 */
+		onMigrate: (args: {
+			db: DB$1;
+			oldVersion: number | undefined;
+			getConstraints: (table: string, column?: string, types?: ColConstraint["type"][]) => Promise<ColConstraint[]>;
+		}) => void;
+	};
+	onLog?: (evt: EventInfo) => Promise<void>;
+};
+declare class Prostgles {
+	opts: ProstglesInitOptions;
+	db?: DB$1;
+	pgp?: PGP$1;
+	dbo?: DBHandlerServer;
+	_dboBuilder?: DboBuilder;
+	get dboBuilder(): DboBuilder;
+	set dboBuilder(d: DboBuilder);
+	publishParser?: PublishParser;
+	authHandler?: AuthHandler;
+	schemaWatch?: SchemaWatch;
+	keywords: {
+		$filter: string;
+		$and: string;
+		$or: string;
+		$not: string;
+	};
+	loaded: boolean;
+	dbEventsManager?: DBEventsManager;
+	fileManager?: FileManager;
+	restApi?: RestApi;
+	tableConfigurator?: TableConfigurator;
+	isMedia(tableName: string): boolean;
+	constructor(params: ProstglesInitOptions);
+	destroyed: boolean;
+	onSchemaChange(event: {
+		command: string;
+		query: string;
+	}): Promise<void>;
+	checkDb(): void;
+	getTSFileName(): {
+		fileName: string;
+		fullPath: string;
+	};
+	private getFileText;
+	getTSFileContent: () => string;
+	/**
+	 * Will write the Schema Typescript definitions to file (tsGeneratedTypesDir)
+	 */
+	writeDBSchema(force?: boolean): void;
+	/**
+	 * Will re-create the dbo object
+	 */
+	refreshDBO: () => Promise<DBHandlerServer>;
+	initWatchSchema: (onReady: OnReadyCallbackBasic) => void;
+	initRestApi: () => Promise<void>;
+	initTableConfig: (reason: OnInitReason) => Promise<any>;
+	initFileTable: () => Promise<{} | undefined>;
+	isSuperUser: boolean;
+	schema_checkIntervalMillis?: NodeJS.Timeout;
+	init: (onReady: OnReadyCallbackBasic, reason: OnInitReason) => Promise<InitResult>;
+	runSQLFile(filePath: string): Promise<number | undefined>;
+	connectedSockets: PRGLIOSocket[];
+	setSocketEvents(): Promise<void>;
+	onSocketConnected: (socket: PRGLIOSocket) => Promise<void>;
+	getClientSchema: (clientReq: Pick<LocalParams, "socket" | "httpReq">) => Promise<ClientSchema>;
+	pushSocketSchema: (socket: PRGLIOSocket) => Promise<void>;
+}
+export type ClientStreamedRequest = {
+	socket: PRGLIOSocket;
+	query: string;
+	options: SQLOptions | undefined;
+	persistConnection?: boolean;
+};
+export type StreamedQuery = ClientStreamedRequest & {
+	cursor: CursorType | undefined;
+	client: pg.Client | undefined;
+	stop?: VoidFunction;
+	onError: ((error: any) => void);
+};
+declare class QueryStreamer {
+	db: DB;
+	dboBuilder: DboBuilder;
+	socketQueries: Record<string, Record<string, StreamedQuery>>;
+	adminClient: pg.Client;
+	constructor(dboBuilder: DboBuilder);
+	getConnection: (onError: ((err: any) => void) | undefined, extraOptions?: pg.ClientConfig) => pg.Client;
+	onDisconnect: (socketId: string) => void;
+	create: (query: ClientStreamedRequest) => Promise<SocketSQLStreamServer>;
+}
+export type PGConstraint = {
+	/**
+	 * Constraint type
+	 */
+	contype: "u" | "p" | "c";
+	/**
+	 * Column ordinal positions
+	 */
+	conkey: number[];
+	/**
+	 * Constraint name
+	 */
+	conname: string;
+	/**
+	 * Table name
+	 */
+	relname: string;
+};
+export type OidInfo = {
+	/**
+	 * Oid
+	 */
+	relid: number;
+	relname: string;
+	schemaname: string;
+};
+export type TableOidInfo = OidInfo & {
+	pkey_columns: string[] | null;
+};
+export type TableOidColumnInfo = OidInfo & {
+	column_name: string;
+	udt_name: string;
+	ordinal_position: number;
+};
+declare class DboBuilder {
+	tablesOrViews?: TableSchema[];
+	/**
+	 * Used in obtaining column names for error messages
+	 */
+	constraints?: PGConstraint[];
+	db: DB$1;
+	dbo: DBHandlerServer;
+	_pubSubManager?: PubSubManager;
+	/**
+	 * Used for db.sql field type details
+	 */
+	DATA_TYPES: {
+		oid: string;
+		typname: PG_COLUMN_UDT_DATA_TYPE;
+	}[] | undefined;
+	USER_TABLES: TableOidInfo[] | undefined;
+	USER_TABLE_COLUMNS: TableOidColumnInfo[] | undefined;
+	queryStreamer: QueryStreamer;
+	get tables(): DbTableInfo[];
+	getPubSubManager: () => Promise<PubSubManager>;
+	tsTypesDefinition?: string;
+	joinGraph?: Graph;
+	private shortestJoinPaths;
+	prostgles: Prostgles;
+	publishParser?: PublishParser;
+	onSchemaChange?: (event: {
+		command: string;
+		query: string;
+	}) => void;
+	private constructor();
+	private init;
+	static create: (prostgles: Prostgles) => Promise<DboBuilder>;
+	destroy(): void;
+	_joins?: Join[];
+	get joins(): Join[];
+	set joins(j: Join[]);
+	getAllJoinPaths(): JoinPaths;
+	prepareShortestJoinPaths: () => Promise<void>;
+	runSQL: (query: string, params: any, options: SQLOptions | undefined, localParams?: LocalParams) => Promise<any>;
+	build(): Promise<DBHandlerServer>;
+	getShortestJoinPath: (viewHandler: ViewHandler$1, target: string) => JoinPaths[number] | undefined;
+	getTX: (cb: TxCB) => Promise<any>;
+}
+export declare const getDBSchema: (dboBuilder: DboBuilder) => string;
+export type DBTableHandlersFromSchema<Schema = void> = Schema extends DBSchema ? {
+	[tov_name in keyof Schema]: Schema[tov_name]["is_view"] extends true ? ViewHandler<Schema[tov_name]["columns"]> : TableHandler<Schema[tov_name]["columns"]>;
+} : Record<string, TableHandler>;
+export type DBOFullyTyped<Schema = void> = Schema extends DBSchema ? (DBTableHandlersFromSchema<Schema> & Pick<DBHandlerServer<DBTableHandlersFromSchema<Schema>>, "tx" | "sql">) : DBHandlerServer;
+export type PublishFullyTyped<Schema = void> = Schema extends DBSchema ? (PublishAllOrNothing | {
+	[tov_name in keyof Partial<Schema>]: PublishAllOrNothing | (Schema[tov_name]["is_view"] extends true ? PublishViewRule<Schema[tov_name]["columns"], Schema> : PublishTableRule<Schema[tov_name]["columns"], Schema>);
+}) : (PublishAllOrNothing | Record<string, PublishViewRule | PublishTableRule | PublishAllOrNothing>);
+
+export {};