import type { DBOFullyTyped, PublishFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
import type { Filter, LocalParams, TableOrViewInfo } from "../DboBuilder/DboBuilder";
import type { DB, DBHandlerServer } from "../Prostgles";
export type Awaitable<T> = T | Promise<T>;
export type DboTable = {
    tableName: string;
    clientReq: AuthClientRequest | undefined;
};
export type DboTableCommand = DboTable & {
    command: string;
};
import type pgPromise from "pg-promise";
import type { AnyObject, DBSchema, FieldFilter, FullFilter, RequiredNestedInsert, SelectParams, SQLHandler, TableSchema } from "prostgles-types";
import type { AuthClientRequest, LoginClientInfo, SessionUser } from "../Auth/AuthTypes";
import type { TableSchemaColumn } from "../DboBuilder/DboBuilderTypes";
import type { ClientHandlers } from "../WebsocketAPI/getClientHandlers";
export type InsertRequestData = {
    data: object | object[];
    returning: FieldFilter;
};
export type SelectRequestData = {
    filter: object;
    params: SelectParams;
};
export type DeleteRequestData = {
    filter: object;
    returning: FieldFilter;
};
export type UpdateRequestDataOne<R extends AnyObject, S extends DBSchema | void = void> = {
    filter: FullFilter<R, S>;
    data: Partial<R>;
    returning: FieldFilter<R>;
};
export type UpdateReq<R extends AnyObject, S extends DBSchema | void = void> = {
    filter: FullFilter<R, S>;
    data: Partial<R>;
};
export type UpdateRequestDataBatch<R extends AnyObject> = {
    data: UpdateReq<R>[];
};
export type UpdateRequestData<R extends AnyObject = AnyObject> = UpdateRequestDataOne<R> | UpdateRequestDataBatch<R>;
export type ValidateRowArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {
    row: R;
    dbx: DBX;
    tx: pgPromise.ITask<{}> | DB;
} & ({
    command: "insert";
    data: R;
} | {
    command: "update";
    data: Partial<R>;
});
export type ValidateRowsArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {
    rows: R[];
    dbx: DBX;
    tx: pgPromise.ITask<{}> | DB;
} & ({
    command: "insert";
    data: R[];
} | {
    command: "update";
    data: Partial<R>[];
});
export type ValidateRowArgs<R = AnyObject, DBX = DBHandlerServer> = ValidateRowArgsCommon<R, 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 PostValidateRowBasic = (args: ValidateRowArgs) => 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 ValidateUpdateRowBasic = (args: ValidateUpdateRowArgs) => AnyObject | Promise<AnyObject>;
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. If undefined will use the fields (allowed to be selected)
     * */
    filterFields?: FieldFilter<Cols>;
    /**
     * Validation logic to check/update data for each request
     */
    validate?(args: SelectRequestData): SelectRequestData | Promise<SelectRequestData>;
    subscribeThrottle?: number;
    disableMethods?: Partial<Record<"sync" | "subscribe", 1>>;
};
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?: S extends DBSchema ? ValidateRow<Cols, S> : ValidateRowBasic;
    /**
     * Validation logic to check/update data for each request. Happens after publish rule checks (for fields, forcedData/forcedFilter)
     */
    validate?: S extends DBSchema ? ValidateRow<Cols, S> : ValidateRowBasic;
    /**
     * 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?: S extends DBSchema ? PostValidateRow<Required<Cols>, S> : PostValidateRowBasic;
    /**
     * If defined then only nested inserts from these tables are allowed
     * Direct inserts will fail
     */
    allowedNestedInserts?: {
        table: string;
        column: string;
    }[];
    requiredNestedInserts?: RequiredNestedInsert[];
};
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?: S extends DBSchema ? ValidateUpdateRow<Cols, S> : ValidateUpdateRowBasic;
    /**
     * 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?: S extends DBSchema ? PostValidateRow<Required<Cols>, S> : PostValidateRowBasic;
    disableMethods?: Partial<Record<"updateBatch", 1>>;
};
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?(filter: FullFilter<Cols, S>): Awaitable<void>;
};
export type SyncConfig<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.
     */
    /**
     * Throttle replication transmission in milliseconds. Defaults to 100
     */
    throttle?: number;
    /**
     * Number of rows to send per trip. Defaults to 50
     */
    batch_size?: number;
};
/**
 * Required but possibly undefined type
 * */
export type Required_ish<T> = {
    [K in keyof Required<T>]: T[K];
};
export type WithRequired<T, K extends keyof T> = T & {
    [P in K]-?: NonNullable<T[P]>;
};
export type TableRule<RowType extends AnyObject = AnyObject, S extends DBSchema | void = void> = {
    select?: SelectRule<RowType, S>;
    insert?: InsertRule<RowType, S>;
    update?: UpdateRule<RowType, S>;
    delete?: DeleteRule<RowType, S>;
    sync?: SyncConfig<RowType>;
};
export type ParsedViewRule<S extends AnyObject = AnyObject> = {
    /**
     * What can be read from the table
     */
    select?: WithRequired<SelectRule<S>, "filterFields" | "orderByFields">;
};
export type ParsedTableRule<RowType extends AnyObject = AnyObject, S extends DBSchema | void = void> = ParsedViewRule<RowType> & {
    insert?: WithRequired<InsertRule<RowType, S>, "returningFields">;
    update?: WithRequired<UpdateRule<RowType, S>, "filterFields" | "returningFields">;
    delete?: WithRequired<DeleteRule<RowType, S>, "returningFields">;
};
export declare const parsePublishTableRule: <R extends ParsedPublishTable>(tableRules: R | undefined) => ParsedTableRule<AnyObject, void> | undefined;
export type PublishTableRule<Col extends AnyObject = AnyObject, S extends DBSchema | void = void> = {
    select?: SelectRule<Col, S> | PublishAllOrNothing;
    insert?: InsertRule<Col, S> | PublishAllOrNothing;
    update?: UpdateRule<Col, S> | PublishAllOrNothing;
    delete?: DeleteRule<Col, S> | PublishAllOrNothing;
};
export declare const TABLE_RULE_NO_LIMITS: {
    readonly select: {
        readonly fields: "*";
        readonly disableMethods: undefined;
        readonly subscribeThrottle: 0;
    };
    readonly insert: {
        readonly fields: "*";
    };
    readonly update: {
        readonly fields: "*";
        readonly filterFields: "*";
    };
    readonly delete: {
        readonly filterFields: "*";
    };
};
export type ParsedPublishTable = {
    select?: SelectRule;
    insert?: InsertRule;
    update?: UpdateRule;
    delete?: DeleteRule;
};
export type DbTableInfo = {
    name: string;
    info: TableOrViewInfo;
    columns: TableSchemaColumn[];
};
export type PermissionScope = {
    allowSql?: boolean;
    tables?: Record<string, Partial<{
        select: true | {
            fields?: FieldFilter;
            forcedFilter?: AnyObject | undefined;
        };
        insert: true | {
            fields?: FieldFilter;
        };
        update: true | {
            fields?: FieldFilter;
            forcedFilter?: AnyObject | undefined;
        };
        delete: true | {
            forcedFilter?: AnyObject | undefined;
        };
    }>>;
    methods?: Record<string, boolean>;
};
export type PublishParams<S = void, SUser extends SessionUser = SessionUser> = {
    sid: string | undefined;
    dbo: DBOFullyTyped<S>;
    db: DB;
    sql: SQLHandler;
    user?: SUser["user"];
    clientReq: AuthClientRequest;
    clientInfo: LoginClientInfo;
    tables: TableSchema[];
    getClientDBHandlers: (
    /**
     * Used to filter permissions
     */
    scope: PermissionScope | undefined) => Promise<ClientHandlers<S>>;
};
export type RequestParams = {
    dbo?: DBHandlerServer;
    socket?: any;
};
export type PublishAllOrNothing = boolean | "*" | null;
export type PublishObject = Record<string, PublishTableRule | PublishAllOrNothing>;
export type ParsedPublishTables = {
    [table_name: string]: ParsedPublishTable;
};
type PublishAllOrNothingRoot = Exclude<PublishAllOrNothing, boolean>;
export type PublishedResult<Schema = void> = PublishAllOrNothingRoot | PublishFullyTyped<Schema>;
export type Publish<Schema = void, SUser extends SessionUser = SessionUser> = PublishedResult<Schema> | ((params: PublishParams<Schema, SUser>) => Awaitable<PublishedResult<Schema>>);
export {};
//# sourceMappingURL=publishTypesAndUtils.d.ts.map