@restura/core 0.1.0-alpha.8 → 0.1.1

package/dist/index.d.mts

@@ -1,34 +1,1180 @@
 import winston from 'winston';
+import { UUID } from 'crypto';
 import * as express from 'express';
+import { IncomingHttpHeaders } from 'http2';
 import { z } from 'zod';
-import { PoolConfig, Pool } from 'pg';
+import { QueryResultRow, QueryConfigValues, QueryResult, PoolConfig, Pool, ClientConfig, Client } from 'pg';
+import peg from 'pegjs';
 
 declare const logger: winston.Logger;
 
+interface RsErrorInternalData {
+    err: ErrorCode;
+    msg: string;
+    stack: string;
+    status: number;
+    message?: string;
+}
+declare enum HtmlStatusCodes {
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    CONFLICT = 409,
+    VERSION_OUT_OF_DATE = 418,// Technically this is the I'm a teapot code that was a joke.
+    SERVER_ERROR = 500,
+    SERVICE_UNAVAILABLE = 503,
+    NETWORK_CONNECT_TIMEOUT = 599
+}
+type ErrorCode = 'UNKNOWN_ERROR' | 'NOT_FOUND' | 'EMAIL_TAKEN' | 'UNAUTHORIZED' | 'FORBIDDEN' | 'CONFLICT' | 'UPDATE_FORBIDDEN' | 'CREATE_FORBIDDEN' | 'DELETE_FORBIDDEN' | 'DELETE_FAILURE' | 'BAD_REQUEST' | 'INVALID_TOKEN' | 'INCORRECT_EMAIL_OR_PASSWORD' | 'DUPLICATE_TOKEN' | 'DUPLICATE_USERNAME' | 'DUPLICATE_EMAIL' | 'DUPLICATE' | 'EMAIL_NOT_VERIFIED' | 'UPDATE_WITHOUT_ID' | 'CONNECTION_ERROR' | 'INVALID_PAYMENT' | 'DECLINED_PAYMENT' | 'INTEGRATION_ERROR' | 'CANNOT_RESERVE' | 'REFUND_FAILURE' | 'INVALID_INVOICE' | 'INVALID_COUPON' | 'SERVICE_UNAVAILABLE' | 'METHOD_UNALLOWED' | 'LOGIN_EXPIRED' | 'THIRD_PARTY_ERROR' | 'ACCESS_DENIED' | 'DATABASE_ERROR' | 'SCHEMA_ERROR';
+declare class RsError {
+    err: ErrorCode;
+    msg: string;
+    status?: number;
+    stack: string;
+    constructor(errCode: ErrorCode, message?: string);
+    static htmlStatus(code: ErrorCode): number;
+    static isRsError(error: unknown): error is RsError;
+}
+
+interface SchemaChangeValue {
+    name: string;
+    changeType: 'NEW' | 'MODIFIED' | 'DELETED';
+}
+interface SchemaPreview {
+    commands: string;
+    endPoints: SchemaChangeValue[];
+    globalParams: SchemaChangeValue[];
+    roles: SchemaChangeValue[];
+    customTypes: boolean;
+}
+type StandardOrderTypes = 'ASC' | 'DESC' | 'RAND' | 'NONE';
+type ConjunctionTypes = 'AND' | 'OR';
+type MatchTypes = 'exact' | 'fuzzy' | 'like' | 'greaterThan' | 'greaterThanEqual' | 'lessThan' | 'lessThanEqual';
+interface RsResponseData<T> {
+    data: T;
+}
+interface RsErrorData {
+    err: string;
+    msg: string;
+    stack?: string;
+}
+interface RsPagedResponseData<T> extends RsResponseData<T> {
+    total: number;
+}
+interface PageQuery {
+    page: number;
+    perPage: number;
+    sortBy: string;
+    sortOrder: StandardOrderTypes;
+    filter?: string;
+    [key: string]: string | number | boolean | object | null | undefined;
+}
+interface AuthenticationUserDetails {
+    role: string;
+    userId?: number;
+    [key: string]: string | number | boolean | object | null | undefined;
+}
+type ValidAuthenticationCallback = (userDetails: AuthenticationUserDetails) => void;
+type AuthenticateHandler = (req: RsRequest<unknown>, res: RsResponse<unknown>, onValid: ValidAuthenticationCallback) => Promise<void>;
+
+interface RsHeaders extends IncomingHttpHeaders {
+    'x-auth-token'?: string;
+}
+type ApiMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
+type RequesterDetails<T extends object = {}> = {
+    role: string;
+    host: string;
+    ipAddress: string;
+    userId?: number;
+    isSystemUser?: boolean;
+} & T;
+interface RsRequest<T = unknown, U extends object = Record<string, unknown>> extends express.Request {
+    requesterDetails: RequesterDetails<U>;
+    data: T;
+}
+type DynamicObject<T = unknown> = {
+    [key: string]: T;
+};
+interface RsResponse<T = unknown> extends express.Response {
+    sendData: (data: T, statusCode?: number) => void;
+    sendNoWrap: (data: T, statusCode?: number) => void;
+    sendError: (err: ErrorCode, msg: string, htmlStatusCode?: HtmlStatusCodes, stack?: string) => void;
+    sendPaginated: (pagedData: RsPagedResponseData<T>, statusCode?: number) => void;
+    _contentLength?: number;
+}
+type RsRouteHandler<T = unknown, U = unknown> = (req: RsRequest<T>, res: RsResponse<U>, next?: express.NextFunction) => Promise<void>;
+interface AsyncExpressApplication {
+    get: (url: string, handler: RsRouteHandler, nextFunction?: RsRouteHandler) => Promise<void> | void;
+    post: (url: string, handler: RsRouteHandler, nextFunction?: RsRouteHandler) => Promise<void> | void;
+    put: (url: string, handler: RsRouteHandler, nextFunction?: RsRouteHandler) => Promise<void> | void;
+    patch: (url: string, handler: RsRouteHandler, nextFunction?: RsRouteHandler) => Promise<void> | void;
+    delete: (url: string, handler: RsRouteHandler, nextFunction?: RsRouteHandler) => Promise<void> | void;
+}
+
+type EventType = 'DATABASE_ROW_DELETE' | 'DATABASE_ROW_INSERT' | 'DATABASE_COLUMN_UPDATE' | 'WEBHOOK';
+type MutationType = 'INSERT' | 'UPDATE' | 'DELETE';
+interface SqlMutationData {
+    mutationType: MutationType;
+    queryMetadata: QueryMetadata;
+}
+interface DatabaseActionData {
+    tableName: string;
+    queryMetadata: QueryMetadata;
+}
+interface ActionRowInsertData<T = DynamicObject> extends DatabaseActionData {
+    insertedId: number;
+    insertObject: T;
+}
+interface ActionRowDeleteData<T = DynamicObject> extends DatabaseActionData {
+    deletedId: number;
+    deletedRow: T;
+}
+interface ActionColumnChangeData<T = DynamicObject> extends DatabaseActionData {
+    tableName: string;
+    changedId: number;
+    newData: T;
+    oldData: T;
+}
+interface ActionRowInsertFilter {
+    tableName: string;
+}
+interface ActionRowDeleteFilter {
+    tableName: string;
+}
+interface ActionColumnChangeFilter {
+    tableName: string;
+    columns: string[];
+}
+type TriggerResult = {
+    table: string;
+    insertedId?: number;
+    changedId?: number;
+    deletedId?: number;
+    queryMetadata: QueryMetadata;
+    record: DynamicObject;
+    previousRecord: DynamicObject;
+    requesterId: number;
+};
+type QueryMetadata = RequesterDetails & {
+    connectionInstanceId: UUID;
+};
+declare class EventManager {
+    private actionHandlers;
+    addRowInsertHandler<T>(onInsert: (data: ActionRowInsertData<T>, queryMetadata: QueryMetadata) => Promise<void>, filter?: ActionRowInsertFilter): void;
+    addColumnChangeHandler<T>(onUpdate: (data: ActionColumnChangeData<T>, queryMetadata: QueryMetadata) => Promise<void>, filter: ActionColumnChangeFilter): void;
+    addRowDeleteHandler<T>(onDelete: (data: ActionRowDeleteData<T>, queryMetadata: QueryMetadata) => Promise<void>, filter?: ActionRowDeleteFilter): void;
+    fireActionFromDbTrigger(sqlMutationData: SqlMutationData, result: TriggerResult): Promise<void>;
+    private fireInsertActions;
+    private fireDeleteActions;
+    private fireUpdateActions;
+    private hasHandlersForEventType;
+}
+declare const eventManager: EventManager;
+
 declare const resturaConfigSchema: z.ZodObject<{
     authToken: z.ZodString;
     sendErrorStackTrace: z.ZodDefault<z.ZodBoolean>;
     schemaFilePath: z.ZodDefault<z.ZodString>;
+    customApiFolderPath: z.ZodDefault<z.ZodString>;
     generatedTypesPath: z.ZodDefault<z.ZodString>;
+    fileTempCachePath: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     authToken: string;
     sendErrorStackTrace: boolean;
     schemaFilePath: string;
+    customApiFolderPath: string;
     generatedTypesPath: string;
+    fileTempCachePath?: string | undefined;
+}, {
+    authToken: string;
+    sendErrorStackTrace?: boolean | undefined;
+    schemaFilePath?: string | undefined;
+    customApiFolderPath?: string | undefined;
+    generatedTypesPath?: string | undefined;
+    fileTempCachePath?: string | undefined;
+}>;
+type ResturaConfigSchema = z.infer<typeof resturaConfigSchema>;
+
+declare const whereDataSchema: z.ZodObject<{
+    tableName: z.ZodOptional<z.ZodString>;
+    columnName: z.ZodOptional<z.ZodString>;
+    operator: z.ZodOptional<z.ZodEnum<["=", "<", ">", "<=", ">=", "!=", "LIKE", "IN", "NOT IN", "STARTS WITH", "ENDS WITH", "IS", "IS NOT"]>>;
+    value: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    custom: z.ZodOptional<z.ZodString>;
+    conjunction: z.ZodOptional<z.ZodEnum<["AND", "OR"]>>;
+}, "strict", z.ZodTypeAny, {
+    value?: string | number | undefined;
+    custom?: string | undefined;
+    tableName?: string | undefined;
+    columnName?: string | undefined;
+    operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+    conjunction?: "AND" | "OR" | undefined;
+}, {
+    value?: string | number | undefined;
+    custom?: string | undefined;
+    tableName?: string | undefined;
+    columnName?: string | undefined;
+    operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+    conjunction?: "AND" | "OR" | undefined;
+}>;
+type WhereData = z.infer<typeof whereDataSchema>;
+declare const joinDataSchema: z.ZodObject<{
+    table: z.ZodString;
+    localColumnName: z.ZodOptional<z.ZodString>;
+    foreignColumnName: z.ZodOptional<z.ZodString>;
+    custom: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<["LEFT", "INNER"]>;
+    alias: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "LEFT" | "INNER";
+    table: string;
+    custom?: string | undefined;
+    localColumnName?: string | undefined;
+    foreignColumnName?: string | undefined;
+    alias?: string | undefined;
+}, {
+    type: "LEFT" | "INNER";
+    table: string;
+    custom?: string | undefined;
+    localColumnName?: string | undefined;
+    foreignColumnName?: string | undefined;
+    alias?: string | undefined;
+}>;
+type JoinData = z.infer<typeof joinDataSchema>;
+declare const responseDataSchema: z.ZodObject<{
+    name: z.ZodString;
+    selector: z.ZodOptional<z.ZodString>;
+    subquery: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        joins: z.ZodArray<z.ZodObject<{
+            table: z.ZodString;
+            localColumnName: z.ZodOptional<z.ZodString>;
+            foreignColumnName: z.ZodOptional<z.ZodString>;
+            custom: z.ZodOptional<z.ZodString>;
+            type: z.ZodEnum<["LEFT", "INNER"]>;
+            alias: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            type: "LEFT" | "INNER";
+            table: string;
+            custom?: string | undefined;
+            localColumnName?: string | undefined;
+            foreignColumnName?: string | undefined;
+            alias?: string | undefined;
+        }, {
+            type: "LEFT" | "INNER";
+            table: string;
+            custom?: string | undefined;
+            localColumnName?: string | undefined;
+            foreignColumnName?: string | undefined;
+            alias?: string | undefined;
+        }>, "many">;
+        where: z.ZodArray<z.ZodObject<{
+            tableName: z.ZodOptional<z.ZodString>;
+            columnName: z.ZodOptional<z.ZodString>;
+            operator: z.ZodOptional<z.ZodEnum<["=", "<", ">", "<=", ">=", "!=", "LIKE", "IN", "NOT IN", "STARTS WITH", "ENDS WITH", "IS", "IS NOT"]>>;
+            value: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+            custom: z.ZodOptional<z.ZodString>;
+            conjunction: z.ZodOptional<z.ZodEnum<["AND", "OR"]>>;
+        }, "strict", z.ZodTypeAny, {
+            value?: string | number | undefined;
+            custom?: string | undefined;
+            tableName?: string | undefined;
+            columnName?: string | undefined;
+            operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+            conjunction?: "AND" | "OR" | undefined;
+        }, {
+            value?: string | number | undefined;
+            custom?: string | undefined;
+            tableName?: string | undefined;
+            columnName?: string | undefined;
+            operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+            conjunction?: "AND" | "OR" | undefined;
+        }>, "many">;
+        properties: z.ZodArray<z.ZodLazy<z.ZodType<any, z.ZodTypeDef, any>>, "many">;
+        groupBy: z.ZodOptional<z.ZodObject<{
+            columnName: z.ZodString;
+            tableName: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            tableName: string;
+            columnName: string;
+        }, {
+            tableName: string;
+            columnName: string;
+        }>>;
+        orderBy: z.ZodOptional<z.ZodObject<{
+            columnName: z.ZodString;
+            order: z.ZodEnum<["ASC", "DESC"]>;
+            tableName: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            tableName: string;
+            columnName: string;
+            order: "ASC" | "DESC";
+        }, {
+            tableName: string;
+            columnName: string;
+            order: "ASC" | "DESC";
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        table: string;
+        joins: {
+            type: "LEFT" | "INNER";
+            table: string;
+            custom?: string | undefined;
+            localColumnName?: string | undefined;
+            foreignColumnName?: string | undefined;
+            alias?: string | undefined;
+        }[];
+        where: {
+            value?: string | number | undefined;
+            custom?: string | undefined;
+            tableName?: string | undefined;
+            columnName?: string | undefined;
+            operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+            conjunction?: "AND" | "OR" | undefined;
+        }[];
+        properties: any[];
+        groupBy?: {
+            tableName: string;
+            columnName: string;
+        } | undefined;
+        orderBy?: {
+            tableName: string;
+            columnName: string;
+            order: "ASC" | "DESC";
+        } | undefined;
+    }, {
+        table: string;
+        joins: {
+            type: "LEFT" | "INNER";
+            table: string;
+            custom?: string | undefined;
+            localColumnName?: string | undefined;
+            foreignColumnName?: string | undefined;
+            alias?: string | undefined;
+        }[];
+        where: {
+            value?: string | number | undefined;
+            custom?: string | undefined;
+            tableName?: string | undefined;
+            columnName?: string | undefined;
+            operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+            conjunction?: "AND" | "OR" | undefined;
+        }[];
+        properties: any[];
+        groupBy?: {
+            tableName: string;
+            columnName: string;
+        } | undefined;
+        orderBy?: {
+            tableName: string;
+            columnName: string;
+            order: "ASC" | "DESC";
+        } | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    selector?: string | undefined;
+    subquery?: {
+        table: string;
+        joins: {
+            type: "LEFT" | "INNER";
+            table: string;
+            custom?: string | undefined;
+            localColumnName?: string | undefined;
+            foreignColumnName?: string | undefined;
+            alias?: string | undefined;
+        }[];
+        where: {
+            value?: string | number | undefined;
+            custom?: string | undefined;
+            tableName?: string | undefined;
+            columnName?: string | undefined;
+            operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+            conjunction?: "AND" | "OR" | undefined;
+        }[];
+        properties: any[];
+        groupBy?: {
+            tableName: string;
+            columnName: string;
+        } | undefined;
+        orderBy?: {
+            tableName: string;
+            columnName: string;
+            order: "ASC" | "DESC";
+        } | undefined;
+    } | undefined;
+}, {
+    name: string;
+    selector?: string | undefined;
+    subquery?: {
+        table: string;
+        joins: {
+            type: "LEFT" | "INNER";
+            table: string;
+            custom?: string | undefined;
+            localColumnName?: string | undefined;
+            foreignColumnName?: string | undefined;
+            alias?: string | undefined;
+        }[];
+        where: {
+            value?: string | number | undefined;
+            custom?: string | undefined;
+            tableName?: string | undefined;
+            columnName?: string | undefined;
+            operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+            conjunction?: "AND" | "OR" | undefined;
+        }[];
+        properties: any[];
+        groupBy?: {
+            tableName: string;
+            columnName: string;
+        } | undefined;
+        orderBy?: {
+            tableName: string;
+            columnName: string;
+            order: "ASC" | "DESC";
+        } | undefined;
+    } | undefined;
+}>;
+type ResponseData = z.infer<typeof responseDataSchema>;
+declare const standardRouteSchema: z.ZodObject<z.objectUtil.extendShape<{
+    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
+    name: z.ZodString;
+    description: z.ZodString;
+    path: z.ZodString;
+    roles: z.ZodArray<z.ZodString, "many">;
+}, {
+    type: z.ZodEnum<["ONE", "ARRAY", "PAGED"]>;
+    table: z.ZodString;
+    joins: z.ZodArray<z.ZodObject<{
+        table: z.ZodString;
+        localColumnName: z.ZodOptional<z.ZodString>;
+        foreignColumnName: z.ZodOptional<z.ZodString>;
+        custom: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<["LEFT", "INNER"]>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        type: "LEFT" | "INNER";
+        table: string;
+        custom?: string | undefined;
+        localColumnName?: string | undefined;
+        foreignColumnName?: string | undefined;
+        alias?: string | undefined;
+    }, {
+        type: "LEFT" | "INNER";
+        table: string;
+        custom?: string | undefined;
+        localColumnName?: string | undefined;
+        foreignColumnName?: string | undefined;
+        alias?: string | undefined;
+    }>, "many">;
+    assignments: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        value: string;
+        name: string;
+    }, {
+        value: string;
+        name: string;
+    }>, "many">;
+    where: z.ZodArray<z.ZodObject<{
+        tableName: z.ZodOptional<z.ZodString>;
+        columnName: z.ZodOptional<z.ZodString>;
+        operator: z.ZodOptional<z.ZodEnum<["=", "<", ">", "<=", ">=", "!=", "LIKE", "IN", "NOT IN", "STARTS WITH", "ENDS WITH", "IS", "IS NOT"]>>;
+        value: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+        custom: z.ZodOptional<z.ZodString>;
+        conjunction: z.ZodOptional<z.ZodEnum<["AND", "OR"]>>;
+    }, "strict", z.ZodTypeAny, {
+        value?: string | number | undefined;
+        custom?: string | undefined;
+        tableName?: string | undefined;
+        columnName?: string | undefined;
+        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+        conjunction?: "AND" | "OR" | undefined;
+    }, {
+        value?: string | number | undefined;
+        custom?: string | undefined;
+        tableName?: string | undefined;
+        columnName?: string | undefined;
+        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+        conjunction?: "AND" | "OR" | undefined;
+    }>, "many">;
+    request: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        required: z.ZodBoolean;
+        isNullable: z.ZodOptional<z.ZodBoolean>;
+        validator: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["TYPE_CHECK", "MIN", "MAX", "ONE_OF"]>;
+            value: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>;
+        }, "strict", z.ZodTypeAny, {
+            type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
+            value: string | number | string[] | number[];
+        }, {
+            type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
+            value: string | number | string[] | number[];
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        required: boolean;
+        validator: {
+            type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
+            value: string | number | string[] | number[];
+        }[];
+        isNullable?: boolean | undefined;
+    }, {
+        name: string;
+        required: boolean;
+        validator: {
+            type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
+            value: string | number | string[] | number[];
+        }[];
+        isNullable?: boolean | undefined;
+    }>, "many">;
+    response: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        selector: z.ZodOptional<z.ZodString>;
+        subquery: z.ZodOptional<z.ZodObject<{
+            table: z.ZodString;
+            joins: z.ZodArray<z.ZodObject<{
+                table: z.ZodString;
+                localColumnName: z.ZodOptional<z.ZodString>;
+                foreignColumnName: z.ZodOptional<z.ZodString>;
+                custom: z.ZodOptional<z.ZodString>;
+                type: z.ZodEnum<["LEFT", "INNER"]>;
+                alias: z.ZodOptional<z.ZodString>;
+            }, "strict", z.ZodTypeAny, {
+                type: "LEFT" | "INNER";
+                table: string;
+                custom?: string | undefined;
+                localColumnName?: string | undefined;
+                foreignColumnName?: string | undefined;
+                alias?: string | undefined;
+            }, {
+                type: "LEFT" | "INNER";
+                table: string;
+                custom?: string | undefined;
+                localColumnName?: string | undefined;
+                foreignColumnName?: string | undefined;
+                alias?: string | undefined;
+            }>, "many">;
+            where: z.ZodArray<z.ZodObject<{
+                tableName: z.ZodOptional<z.ZodString>;
+                columnName: z.ZodOptional<z.ZodString>;
+                operator: z.ZodOptional<z.ZodEnum<["=", "<", ">", "<=", ">=", "!=", "LIKE", "IN", "NOT IN", "STARTS WITH", "ENDS WITH", "IS", "IS NOT"]>>;
+                value: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+                custom: z.ZodOptional<z.ZodString>;
+                conjunction: z.ZodOptional<z.ZodEnum<["AND", "OR"]>>;
+            }, "strict", z.ZodTypeAny, {
+                value?: string | number | undefined;
+                custom?: string | undefined;
+                tableName?: string | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+                conjunction?: "AND" | "OR" | undefined;
+            }, {
+                value?: string | number | undefined;
+                custom?: string | undefined;
+                tableName?: string | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+                conjunction?: "AND" | "OR" | undefined;
+            }>, "many">;
+            properties: z.ZodArray<z.ZodLazy<z.ZodType<any, z.ZodTypeDef, any>>, "many">;
+            groupBy: z.ZodOptional<z.ZodObject<{
+                columnName: z.ZodString;
+                tableName: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                tableName: string;
+                columnName: string;
+            }, {
+                tableName: string;
+                columnName: string;
+            }>>;
+            orderBy: z.ZodOptional<z.ZodObject<{
+                columnName: z.ZodString;
+                order: z.ZodEnum<["ASC", "DESC"]>;
+                tableName: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                tableName: string;
+                columnName: string;
+                order: "ASC" | "DESC";
+            }, {
+                tableName: string;
+                columnName: string;
+                order: "ASC" | "DESC";
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            table: string;
+            joins: {
+                type: "LEFT" | "INNER";
+                table: string;
+                custom?: string | undefined;
+                localColumnName?: string | undefined;
+                foreignColumnName?: string | undefined;
+                alias?: string | undefined;
+            }[];
+            where: {
+                value?: string | number | undefined;
+                custom?: string | undefined;
+                tableName?: string | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+                conjunction?: "AND" | "OR" | undefined;
+            }[];
+            properties: any[];
+            groupBy?: {
+                tableName: string;
+                columnName: string;
+            } | undefined;
+            orderBy?: {
+                tableName: string;
+                columnName: string;
+                order: "ASC" | "DESC";
+            } | undefined;
+        }, {
+            table: string;
+            joins: {
+                type: "LEFT" | "INNER";
+                table: string;
+                custom?: string | undefined;
+                localColumnName?: string | undefined;
+                foreignColumnName?: string | undefined;
+                alias?: string | undefined;
+            }[];
+            where: {
+                value?: string | number | undefined;
+                custom?: string | undefined;
+                tableName?: string | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+                conjunction?: "AND" | "OR" | undefined;
+            }[];
+            properties: any[];
+            groupBy?: {
+                tableName: string;
+                columnName: string;
+            } | undefined;
+            orderBy?: {
+                tableName: string;
+                columnName: string;
+                order: "ASC" | "DESC";
+            } | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        selector?: string | undefined;
+        subquery?: {
+            table: string;
+            joins: {
+                type: "LEFT" | "INNER";
+                table: string;
+                custom?: string | undefined;
+                localColumnName?: string | undefined;
+                foreignColumnName?: string | undefined;
+                alias?: string | undefined;
+            }[];
+            where: {
+                value?: string | number | undefined;
+                custom?: string | undefined;
+                tableName?: string | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+                conjunction?: "AND" | "OR" | undefined;
+            }[];
+            properties: any[];
+            groupBy?: {
+                tableName: string;
+                columnName: string;
+            } | undefined;
+            orderBy?: {
+                tableName: string;
+                columnName: string;
+                order: "ASC" | "DESC";
+            } | undefined;
+        } | undefined;
+    }, {
+        name: string;
+        selector?: string | undefined;
+        subquery?: {
+            table: string;
+            joins: {
+                type: "LEFT" | "INNER";
+                table: string;
+                custom?: string | undefined;
+                localColumnName?: string | undefined;
+                foreignColumnName?: string | undefined;
+                alias?: string | undefined;
+            }[];
+            where: {
+                value?: string | number | undefined;
+                custom?: string | undefined;
+                tableName?: string | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+                conjunction?: "AND" | "OR" | undefined;
+            }[];
+            properties: any[];
+            groupBy?: {
+                tableName: string;
+                columnName: string;
+            } | undefined;
+            orderBy?: {
+                tableName: string;
+                columnName: string;
+                order: "ASC" | "DESC";
+            } | undefined;
+        } | undefined;
+    }>, "many">;
+    groupBy: z.ZodOptional<z.ZodObject<{
+        columnName: z.ZodString;
+        tableName: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        tableName: string;
+        columnName: string;
+    }, {
+        tableName: string;
+        columnName: string;
+    }>>;
+    orderBy: z.ZodOptional<z.ZodObject<{
+        columnName: z.ZodString;
+        order: z.ZodEnum<["ASC", "DESC"]>;
+        tableName: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        tableName: string;
+        columnName: string;
+        order: "ASC" | "DESC";
+    }, {
+        tableName: string;
+        columnName: string;
+        order: "ASC" | "DESC";
+    }>>;
+}>, "strict", z.ZodTypeAny, {
+    path: string;
+    type: "ONE" | "ARRAY" | "PAGED";
+    name: string;
+    table: string;
+    joins: {
+        type: "LEFT" | "INNER";
+        table: string;
+        custom?: string | undefined;
+        localColumnName?: string | undefined;
+        foreignColumnName?: string | undefined;
+        alias?: string | undefined;
+    }[];
+    where: {
+        value?: string | number | undefined;
+        custom?: string | undefined;
+        tableName?: string | undefined;
+        columnName?: string | undefined;
+        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+        conjunction?: "AND" | "OR" | undefined;
+    }[];
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    description: string;
+    roles: string[];
+    assignments: {
+        value: string;
+        name: string;
+    }[];
+    request: {
+        name: string;
+        required: boolean;
+        validator: {
+            type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
+            value: string | number | string[] | number[];
+        }[];
+        isNullable?: boolean | undefined;
+    }[];
+    response: {
+        name: string;
+        selector?: string | undefined;
+        subquery?: {
+            table: string;
+            joins: {
+                type: "LEFT" | "INNER";
+                table: string;
+                custom?: string | undefined;
+                localColumnName?: string | undefined;
+                foreignColumnName?: string | undefined;
+                alias?: string | undefined;
+            }[];
+            where: {
+                value?: string | number | undefined;
+                custom?: string | undefined;
+                tableName?: string | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+                conjunction?: "AND" | "OR" | undefined;
+            }[];
+            properties: any[];
+            groupBy?: {
+                tableName: string;
+                columnName: string;
+            } | undefined;
+            orderBy?: {
+                tableName: string;
+                columnName: string;
+                order: "ASC" | "DESC";
+            } | undefined;
+        } | undefined;
+    }[];
+    groupBy?: {
+        tableName: string;
+        columnName: string;
+    } | undefined;
+    orderBy?: {
+        tableName: string;
+        columnName: string;
+        order: "ASC" | "DESC";
+    } | undefined;
+}, {
+    path: string;
+    type: "ONE" | "ARRAY" | "PAGED";
+    name: string;
+    table: string;
+    joins: {
+        type: "LEFT" | "INNER";
+        table: string;
+        custom?: string | undefined;
+        localColumnName?: string | undefined;
+        foreignColumnName?: string | undefined;
+        alias?: string | undefined;
+    }[];
+    where: {
+        value?: string | number | undefined;
+        custom?: string | undefined;
+        tableName?: string | undefined;
+        columnName?: string | undefined;
+        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+        conjunction?: "AND" | "OR" | undefined;
+    }[];
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    description: string;
+    roles: string[];
+    assignments: {
+        value: string;
+        name: string;
+    }[];
+    request: {
+        name: string;
+        required: boolean;
+        validator: {
+            type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
+            value: string | number | string[] | number[];
+        }[];
+        isNullable?: boolean | undefined;
+    }[];
+    response: {
+        name: string;
+        selector?: string | undefined;
+        subquery?: {
+            table: string;
+            joins: {
+                type: "LEFT" | "INNER";
+                table: string;
+                custom?: string | undefined;
+                localColumnName?: string | undefined;
+                foreignColumnName?: string | undefined;
+                alias?: string | undefined;
+            }[];
+            where: {
+                value?: string | number | undefined;
+                custom?: string | undefined;
+                tableName?: string | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
+                conjunction?: "AND" | "OR" | undefined;
+            }[];
+            properties: any[];
+            groupBy?: {
+                tableName: string;
+                columnName: string;
+            } | undefined;
+            orderBy?: {
+                tableName: string;
+                columnName: string;
+                order: "ASC" | "DESC";
+            } | undefined;
+        } | undefined;
+    }[];
+    groupBy?: {
+        tableName: string;
+        columnName: string;
+    } | undefined;
+    orderBy?: {
+        tableName: string;
+        columnName: string;
+        order: "ASC" | "DESC";
+    } | undefined;
+}>;
+type StandardRouteData = z.infer<typeof standardRouteSchema>;
+declare const customRouteSchema: z.ZodObject<z.objectUtil.extendShape<{
+    method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
+    name: z.ZodString;
+    description: z.ZodString;
+    path: z.ZodString;
+    roles: z.ZodArray<z.ZodString, "many">;
+}, {
+    type: z.ZodEnum<["CUSTOM_ONE", "CUSTOM_ARRAY", "CUSTOM_PAGED"]>;
+    responseType: z.ZodUnion<[z.ZodString, z.ZodEnum<["string", "number", "boolean"]>]>;
+    requestType: z.ZodOptional<z.ZodString>;
+    request: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        required: z.ZodBoolean;
+        isNullable: z.ZodOptional<z.ZodBoolean>;
+        validator: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["TYPE_CHECK", "MIN", "MAX", "ONE_OF"]>;
+            value: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>;
+        }, "strict", z.ZodTypeAny, {
+            type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
+            value: string | number | string[] | number[];
+        }, {
+            type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
+            value: string | number | string[] | number[];
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        required: boolean;
+        validator: {
+            type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
+            value: string | number | string[] | number[];
+        }[];
+        isNullable?: boolean | undefined;
+    }, {
+        name: string;
+        required: boolean;
+        validator: {
+            type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
+            value: string | number | string[] | number[];
+        }[];
+        isNullable?: boolean | undefined;
+    }>, "many">>;
+    table: z.ZodUndefined;
+    joins: z.ZodUndefined;
+    assignments: z.ZodUndefined;
+    fileUploadType: z.ZodOptional<z.ZodEnum<["SINGLE", "MULTIPLE"]>>;
+}>, "strict", z.ZodTypeAny, {
+    path: string;
+    type: "CUSTOM_ONE" | "CUSTOM_ARRAY" | "CUSTOM_PAGED";
+    name: string;
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    description: string;
+    roles: string[];
+    responseType: string;
+    table?: undefined;
+    joins?: undefined;
+    assignments?: undefined;
+    request?: {
+        name: string;
+        required: boolean;
+        validator: {
+            type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
+            value: string | number | string[] | number[];
+        }[];
+        isNullable?: boolean | undefined;
+    }[] | undefined;
+    requestType?: string | undefined;
+    fileUploadType?: "SINGLE" | "MULTIPLE" | undefined;
+}, {
+    path: string;
+    type: "CUSTOM_ONE" | "CUSTOM_ARRAY" | "CUSTOM_PAGED";
+    name: string;
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    description: string;
+    roles: string[];
+    responseType: string;
+    table?: undefined;
+    joins?: undefined;
+    assignments?: undefined;
+    request?: {
+        name: string;
+        required: boolean;
+        validator: {
+            type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
+            value: string | number | string[] | number[];
+        }[];
+        isNullable?: boolean | undefined;
+    }[] | undefined;
+    requestType?: string | undefined;
+    fileUploadType?: "SINGLE" | "MULTIPLE" | undefined;
+}>;
+type CustomRouteData = z.infer<typeof customRouteSchema>;
+type RouteData = CustomRouteData | StandardRouteData;
+declare const tableDataSchema: z.ZodObject<{
+    name: z.ZodString;
+    columns: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodUnion<[z.ZodEnum<["SMALLINT", "INTEGER", "BIGINT", "DECIMAL", "NUMERIC", "REAL", "DOUBLE PRECISION", "SERIAL", "BIGSERIAL"]>, z.ZodEnum<["CHAR", "VARCHAR", "TEXT", "BYTEA"]>, z.ZodEnum<["DATE", "TIMESTAMP", "TIMESTAMPTZ", "TIME", "INTERVAL"]>, z.ZodEnum<["JSON", "JSONB"]>, z.ZodEnum<["BOOLEAN", "TINYINT", "SMALLINT", "MEDIUMINT", "INTEGER", "BIGINT", "DECIMAL", "FLOAT", "DOUBLE"]>, z.ZodEnum<["CHAR", "VARCHAR", "TINYTEXT", "TINYBLOB", "TEXT", "BLOB", "MEDIUMTEXT", "MEDIUMBLOB", "LONGTEXT", "JSON", "LONGBLOB", "ENUM"]>, z.ZodEnum<["DATE", "DATETIME", "TIME", "TIMESTAMP"]>]>;
+        isNullable: z.ZodBoolean;
+        roles: z.ZodArray<z.ZodString, "many">;
+        comment: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodString>;
+        value: z.ZodOptional<z.ZodString>;
+        isPrimary: z.ZodOptional<z.ZodBoolean>;
+        isUnique: z.ZodOptional<z.ZodBoolean>;
+        hasAutoIncrement: z.ZodOptional<z.ZodBoolean>;
+        length: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "JSON" | "JSONB" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "LONGBLOB" | "ENUM" | "DATETIME";
+        name: string;
+        isNullable: boolean;
+        roles: string[];
+        length?: number | undefined;
+        value?: string | undefined;
+        default?: string | undefined;
+        comment?: string | undefined;
+        isPrimary?: boolean | undefined;
+        isUnique?: boolean | undefined;
+        hasAutoIncrement?: boolean | undefined;
+    }, {
+        type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "JSON" | "JSONB" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "LONGBLOB" | "ENUM" | "DATETIME";
+        name: string;
+        isNullable: boolean;
+        roles: string[];
+        length?: number | undefined;
+        value?: string | undefined;
+        default?: string | undefined;
+        comment?: string | undefined;
+        isPrimary?: boolean | undefined;
+        isUnique?: boolean | undefined;
+        hasAutoIncrement?: boolean | undefined;
+    }>, "many">;
+    indexes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        columns: z.ZodArray<z.ZodString, "many">;
+        isUnique: z.ZodBoolean;
+        isPrimaryKey: z.ZodBoolean;
+        order: z.ZodEnum<["ASC", "DESC"]>;
+    }, "strict", z.ZodTypeAny, {
+        order: "ASC" | "DESC";
+        name: string;
+        isUnique: boolean;
+        columns: string[];
+        isPrimaryKey: boolean;
+    }, {
+        order: "ASC" | "DESC";
+        name: string;
+        isUnique: boolean;
+        columns: string[];
+        isPrimaryKey: boolean;
+    }>, "many">;
+    foreignKeys: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        column: z.ZodString;
+        refTable: z.ZodString;
+        refColumn: z.ZodString;
+        onDelete: z.ZodEnum<["CASCADE", "SET NULL", "RESTRICT", "NO ACTION", "SET DEFAULT"]>;
+        onUpdate: z.ZodEnum<["CASCADE", "SET NULL", "RESTRICT", "NO ACTION", "SET DEFAULT"]>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        column: string;
+        refTable: string;
+        refColumn: string;
+        onDelete: "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION" | "SET DEFAULT";
+        onUpdate: "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION" | "SET DEFAULT";
+    }, {
+        name: string;
+        column: string;
+        refTable: string;
+        refColumn: string;
+        onDelete: "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION" | "SET DEFAULT";
+        onUpdate: "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION" | "SET DEFAULT";
+    }>, "many">;
+    checkConstraints: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        check: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        check: string;
+    }, {
+        name: string;
+        check: string;
+    }>, "many">;
+    roles: z.ZodArray<z.ZodString, "many">;
+    notify: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"ALL">, z.ZodArray<z.ZodString, "many">]>>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    roles: string[];
+    columns: {
+        type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "JSON" | "JSONB" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "LONGBLOB" | "ENUM" | "DATETIME";
+        name: string;
+        isNullable: boolean;
+        roles: string[];
+        length?: number | undefined;
+        value?: string | undefined;
+        default?: string | undefined;
+        comment?: string | undefined;
+        isPrimary?: boolean | undefined;
+        isUnique?: boolean | undefined;
+        hasAutoIncrement?: boolean | undefined;
+    }[];
+    indexes: {
+        order: "ASC" | "DESC";
+        name: string;
+        isUnique: boolean;
+        columns: string[];
+        isPrimaryKey: boolean;
+    }[];
+    foreignKeys: {
+        name: string;
+        column: string;
+        refTable: string;
+        refColumn: string;
+        onDelete: "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION" | "SET DEFAULT";
+        onUpdate: "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION" | "SET DEFAULT";
+    }[];
+    checkConstraints: {
+        name: string;
+        check: string;
+    }[];
+    notify?: string[] | "ALL" | undefined;
 }, {
-    authToken: string;
-    sendErrorStackTrace?: boolean | undefined;
-    schemaFilePath?: string | undefined;
-    generatedTypesPath?: string | undefined;
+    name: string;
+    roles: string[];
+    columns: {
+        type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "JSON" | "JSONB" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "LONGBLOB" | "ENUM" | "DATETIME";
+        name: string;
+        isNullable: boolean;
+        roles: string[];
+        length?: number | undefined;
+        value?: string | undefined;
+        default?: string | undefined;
+        comment?: string | undefined;
+        isPrimary?: boolean | undefined;
+        isUnique?: boolean | undefined;
+        hasAutoIncrement?: boolean | undefined;
+    }[];
+    indexes: {
+        order: "ASC" | "DESC";
+        name: string;
+        isUnique: boolean;
+        columns: string[];
+        isPrimaryKey: boolean;
+    }[];
+    foreignKeys: {
+        name: string;
+        column: string;
+        refTable: string;
+        refColumn: string;
+        onDelete: "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION" | "SET DEFAULT";
+        onUpdate: "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION" | "SET DEFAULT";
+    }[];
+    checkConstraints: {
+        name: string;
+        check: string;
+    }[];
+    notify?: string[] | "ALL" | undefined;
 }>;
-type ResturaConfigSchema = z.infer<typeof resturaConfigSchema>;
-
-declare const resturaZodSchema: z.ZodObject<{
+type TableData = z.infer<typeof tableDataSchema>;
+declare const resturaSchema: z.ZodObject<{
     database: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         columns: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
-            type: z.ZodUnion<[z.ZodEnum<["SMALLINT", "INTEGER", "BIGINT", "DECIMAL", "NUMERIC", "REAL", "DOUBLE PRECISION", "SERIAL", "BIGSERIAL"]>, z.ZodEnum<["CHAR", "VARCHAR", "TEXT", "BYTEA"]>, z.ZodEnum<["DATE", "TIMESTAMP", "TIMESTAMPTZ", "TIME", "INTERVAL"]>, z.ZodEnum<["BOOLEAN", "TINYINT", "SMALLINT", "MEDIUMINT", "INTEGER", "BIGINT", "DECIMAL", "FLOAT", "DOUBLE"]>, z.ZodEnum<["CHAR", "VARCHAR", "TINYTEXT", "TINYBLOB", "TEXT", "BLOB", "MEDIUMTEXT", "MEDIUMBLOB", "LONGTEXT", "JSON", "LONGBLOB", "ENUM"]>, z.ZodEnum<["DATE", "DATETIME", "TIME", "TIMESTAMP"]>]>;
+            type: z.ZodUnion<[z.ZodEnum<["SMALLINT", "INTEGER", "BIGINT", "DECIMAL", "NUMERIC", "REAL", "DOUBLE PRECISION", "SERIAL", "BIGSERIAL"]>, z.ZodEnum<["CHAR", "VARCHAR", "TEXT", "BYTEA"]>, z.ZodEnum<["DATE", "TIMESTAMP", "TIMESTAMPTZ", "TIME", "INTERVAL"]>, z.ZodEnum<["JSON", "JSONB"]>, z.ZodEnum<["BOOLEAN", "TINYINT", "SMALLINT", "MEDIUMINT", "INTEGER", "BIGINT", "DECIMAL", "FLOAT", "DOUBLE"]>, z.ZodEnum<["CHAR", "VARCHAR", "TINYTEXT", "TINYBLOB", "TEXT", "BLOB", "MEDIUMTEXT", "MEDIUMBLOB", "LONGTEXT", "JSON", "LONGBLOB", "ENUM"]>, z.ZodEnum<["DATE", "DATETIME", "TIME", "TIMESTAMP"]>]>;
             isNullable: z.ZodBoolean;
             roles: z.ZodArray<z.ZodString, "many">;
             comment: z.ZodOptional<z.ZodString>;
@@ -39,10 +1185,10 @@ declare const resturaZodSchema: z.ZodObject<{
             hasAutoIncrement: z.ZodOptional<z.ZodBoolean>;
             length: z.ZodOptional<z.ZodNumber>;
         }, "strict", z.ZodTypeAny, {
-            type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "JSON" | "LONGBLOB" | "ENUM" | "DATETIME";
+            type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "JSON" | "JSONB" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "LONGBLOB" | "ENUM" | "DATETIME";
             name: string;
-            roles: string[];
             isNullable: boolean;
+            roles: string[];
             length?: number | undefined;
             value?: string | undefined;
             default?: string | undefined;
@@ -51,10 +1197,10 @@ declare const resturaZodSchema: z.ZodObject<{
             isUnique?: boolean | undefined;
             hasAutoIncrement?: boolean | undefined;
         }, {
-            type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "JSON" | "LONGBLOB" | "ENUM" | "DATETIME";
+            type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "JSON" | "JSONB" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "LONGBLOB" | "ENUM" | "DATETIME";
             name: string;
-            roles: string[];
             isNullable: boolean;
+            roles: string[];
             length?: number | undefined;
             value?: string | undefined;
             default?: string | undefined;
@@ -115,14 +1261,15 @@ declare const resturaZodSchema: z.ZodObject<{
             check: string;
         }>, "many">;
         roles: z.ZodArray<z.ZodString, "many">;
+        notify: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"ALL">, z.ZodArray<z.ZodString, "many">]>>;
     }, "strict", z.ZodTypeAny, {
         name: string;
         roles: string[];
         columns: {
-            type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "JSON" | "LONGBLOB" | "ENUM" | "DATETIME";
+            type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "JSON" | "JSONB" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "LONGBLOB" | "ENUM" | "DATETIME";
             name: string;
-            roles: string[];
             isNullable: boolean;
+            roles: string[];
             length?: number | undefined;
             value?: string | undefined;
             default?: string | undefined;
@@ -150,14 +1297,15 @@ declare const resturaZodSchema: z.ZodObject<{
             name: string;
             check: string;
         }[];
+        notify?: string[] | "ALL" | undefined;
     }, {
         name: string;
         roles: string[];
         columns: {
-            type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "JSON" | "LONGBLOB" | "ENUM" | "DATETIME";
+            type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "JSON" | "JSONB" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "LONGBLOB" | "ENUM" | "DATETIME";
             name: string;
-            roles: string[];
             isNullable: boolean;
+            roles: string[];
             length?: number | undefined;
             value?: string | undefined;
             default?: string | undefined;
@@ -185,6 +1333,7 @@ declare const resturaZodSchema: z.ZodObject<{
             name: string;
             check: string;
         }[];
+        notify?: string[] | "ALL" | undefined;
     }>, "many">;
     endpoints: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -234,28 +1383,29 @@ declare const resturaZodSchema: z.ZodObject<{
             where: z.ZodArray<z.ZodObject<{
                 tableName: z.ZodOptional<z.ZodString>;
                 columnName: z.ZodOptional<z.ZodString>;
-                operator: z.ZodOptional<z.ZodEnum<["=", "<", ">", "<=", ">=", "!=", "LIKE", "IN", "NOT IN", "STARTS WITH", "ENDS WITH"]>>;
+                operator: z.ZodOptional<z.ZodEnum<["=", "<", ">", "<=", ">=", "!=", "LIKE", "IN", "NOT IN", "STARTS WITH", "ENDS WITH", "IS", "IS NOT"]>>;
                 value: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
                 custom: z.ZodOptional<z.ZodString>;
                 conjunction: z.ZodOptional<z.ZodEnum<["AND", "OR"]>>;
             }, "strict", z.ZodTypeAny, {
                 value?: string | number | undefined;
                 custom?: string | undefined;
-                columnName?: string | undefined;
                 tableName?: string | undefined;
-                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                 conjunction?: "AND" | "OR" | undefined;
             }, {
                 value?: string | number | undefined;
                 custom?: string | undefined;
-                columnName?: string | undefined;
                 tableName?: string | undefined;
-                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                 conjunction?: "AND" | "OR" | undefined;
             }>, "many">;
             request: z.ZodArray<z.ZodObject<{
                 name: z.ZodString;
                 required: z.ZodBoolean;
+                isNullable: z.ZodOptional<z.ZodBoolean>;
                 validator: z.ZodArray<z.ZodObject<{
                     type: z.ZodEnum<["TYPE_CHECK", "MIN", "MAX", "ONE_OF"]>;
                     value: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>;
@@ -267,19 +1417,21 @@ declare const resturaZodSchema: z.ZodObject<{
                     value: string | number | string[] | number[];
                 }>, "many">;
             }, "strict", z.ZodTypeAny, {
+                name: string;
+                required: boolean;
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
+                isNullable?: boolean | undefined;
+            }, {
                 name: string;
                 required: boolean;
-            }, {
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
-                name: string;
-                required: boolean;
+                isNullable?: boolean | undefined;
             }>, "many">;
             response: z.ZodArray<z.ZodObject<{
                 name: z.ZodString;
@@ -311,23 +1463,23 @@ declare const resturaZodSchema: z.ZodObject<{
                     where: z.ZodArray<z.ZodObject<{
                         tableName: z.ZodOptional<z.ZodString>;
                         columnName: z.ZodOptional<z.ZodString>;
-                        operator: z.ZodOptional<z.ZodEnum<["=", "<", ">", "<=", ">=", "!=", "LIKE", "IN", "NOT IN", "STARTS WITH", "ENDS WITH"]>>;
+                        operator: z.ZodOptional<z.ZodEnum<["=", "<", ">", "<=", ">=", "!=", "LIKE", "IN", "NOT IN", "STARTS WITH", "ENDS WITH", "IS", "IS NOT"]>>;
                         value: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
                         custom: z.ZodOptional<z.ZodString>;
                         conjunction: z.ZodOptional<z.ZodEnum<["AND", "OR"]>>;
                     }, "strict", z.ZodTypeAny, {
                         value?: string | number | undefined;
                         custom?: string | undefined;
-                        columnName?: string | undefined;
                         tableName?: string | undefined;
-                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                        columnName?: string | undefined;
+                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                         conjunction?: "AND" | "OR" | undefined;
                     }, {
                         value?: string | number | undefined;
                         custom?: string | undefined;
-                        columnName?: string | undefined;
                         tableName?: string | undefined;
-                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                        columnName?: string | undefined;
+                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                         conjunction?: "AND" | "OR" | undefined;
                     }>, "many">;
                     properties: z.ZodArray<z.ZodLazy<z.ZodType<any, z.ZodTypeDef, any>>, "many">;
@@ -335,24 +1487,24 @@ declare const resturaZodSchema: z.ZodObject<{
                         columnName: z.ZodString;
                         tableName: z.ZodString;
                     }, "strict", z.ZodTypeAny, {
-                        columnName: string;
                         tableName: string;
-                    }, {
                         columnName: string;
+                    }, {
                         tableName: string;
+                        columnName: string;
                     }>>;
                     orderBy: z.ZodOptional<z.ZodObject<{
                         columnName: z.ZodString;
                         order: z.ZodEnum<["ASC", "DESC"]>;
                         tableName: z.ZodString;
                     }, "strict", z.ZodTypeAny, {
+                        tableName: string;
                         columnName: string;
                         order: "ASC" | "DESC";
-                        tableName: string;
                     }, {
+                        tableName: string;
                         columnName: string;
                         order: "ASC" | "DESC";
-                        tableName: string;
                     }>>;
                 }, "strip", z.ZodTypeAny, {
                     table: string;
@@ -367,20 +1519,20 @@ declare const resturaZodSchema: z.ZodObject<{
                     where: {
                         value?: string | number | undefined;
                         custom?: string | undefined;
-                        columnName?: string | undefined;
                         tableName?: string | undefined;
-                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                        columnName?: string | undefined;
+                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                         conjunction?: "AND" | "OR" | undefined;
                     }[];
                     properties: any[];
                     groupBy?: {
-                        columnName: string;
                         tableName: string;
+                        columnName: string;
                     } | undefined;
                     orderBy?: {
+                        tableName: string;
                         columnName: string;
                         order: "ASC" | "DESC";
-                        tableName: string;
                     } | undefined;
                 }, {
                     table: string;
@@ -395,20 +1547,20 @@ declare const resturaZodSchema: z.ZodObject<{
                     where: {
                         value?: string | number | undefined;
                         custom?: string | undefined;
-                        columnName?: string | undefined;
                         tableName?: string | undefined;
-                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                        columnName?: string | undefined;
+                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                         conjunction?: "AND" | "OR" | undefined;
                     }[];
                     properties: any[];
                     groupBy?: {
-                        columnName: string;
                         tableName: string;
+                        columnName: string;
                     } | undefined;
                     orderBy?: {
+                        tableName: string;
                         columnName: string;
                         order: "ASC" | "DESC";
-                        tableName: string;
                     } | undefined;
                 }>>;
             }, "strict", z.ZodTypeAny, {
@@ -427,20 +1579,20 @@ declare const resturaZodSchema: z.ZodObject<{
                     where: {
                         value?: string | number | undefined;
                         custom?: string | undefined;
-                        columnName?: string | undefined;
                         tableName?: string | undefined;
-                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                        columnName?: string | undefined;
+                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                         conjunction?: "AND" | "OR" | undefined;
                     }[];
                     properties: any[];
                     groupBy?: {
-                        columnName: string;
                         tableName: string;
+                        columnName: string;
                     } | undefined;
                     orderBy?: {
+                        tableName: string;
                         columnName: string;
                         order: "ASC" | "DESC";
-                        tableName: string;
                     } | undefined;
                 } | undefined;
             }, {
@@ -459,20 +1611,20 @@ declare const resturaZodSchema: z.ZodObject<{
                     where: {
                         value?: string | number | undefined;
                         custom?: string | undefined;
-                        columnName?: string | undefined;
                         tableName?: string | undefined;
-                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                        columnName?: string | undefined;
+                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                         conjunction?: "AND" | "OR" | undefined;
                     }[];
                     properties: any[];
                     groupBy?: {
-                        columnName: string;
                         tableName: string;
+                        columnName: string;
                     } | undefined;
                     orderBy?: {
+                        tableName: string;
                         columnName: string;
                         order: "ASC" | "DESC";
-                        tableName: string;
                     } | undefined;
                 } | undefined;
             }>, "many">;
@@ -480,28 +1632,28 @@ declare const resturaZodSchema: z.ZodObject<{
                 columnName: z.ZodString;
                 tableName: z.ZodString;
             }, "strict", z.ZodTypeAny, {
-                columnName: string;
                 tableName: string;
-            }, {
                 columnName: string;
+            }, {
                 tableName: string;
+                columnName: string;
             }>>;
             orderBy: z.ZodOptional<z.ZodObject<{
                 columnName: z.ZodString;
                 order: z.ZodEnum<["ASC", "DESC"]>;
                 tableName: z.ZodString;
             }, "strict", z.ZodTypeAny, {
+                tableName: string;
                 columnName: string;
                 order: "ASC" | "DESC";
-                tableName: string;
             }, {
+                tableName: string;
                 columnName: string;
                 order: "ASC" | "DESC";
-                tableName: string;
             }>>;
         }>, "strict", z.ZodTypeAny, {
             path: string;
-            type: "PAGED" | "ARRAY" | "ONE";
+            type: "ONE" | "ARRAY" | "PAGED";
             name: string;
             table: string;
             joins: {
@@ -515,9 +1667,9 @@ declare const resturaZodSchema: z.ZodObject<{
             where: {
                 value?: string | number | undefined;
                 custom?: string | undefined;
-                columnName?: string | undefined;
                 tableName?: string | undefined;
-                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                 conjunction?: "AND" | "OR" | undefined;
             }[];
             method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
@@ -528,12 +1680,13 @@ declare const resturaZodSchema: z.ZodObject<{
                 name: string;
             }[];
             request: {
+                name: string;
+                required: boolean;
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
-                name: string;
-                required: boolean;
+                isNullable?: boolean | undefined;
             }[];
             response: {
                 name: string;
@@ -551,35 +1704,35 @@ declare const resturaZodSchema: z.ZodObject<{
                     where: {
                         value?: string | number | undefined;
                         custom?: string | undefined;
-                        columnName?: string | undefined;
                         tableName?: string | undefined;
-                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                        columnName?: string | undefined;
+                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                         conjunction?: "AND" | "OR" | undefined;
                     }[];
                     properties: any[];
                     groupBy?: {
-                        columnName: string;
                         tableName: string;
+                        columnName: string;
                     } | undefined;
                     orderBy?: {
+                        tableName: string;
                         columnName: string;
                         order: "ASC" | "DESC";
-                        tableName: string;
                     } | undefined;
                 } | undefined;
             }[];
             groupBy?: {
-                columnName: string;
                 tableName: string;
+                columnName: string;
             } | undefined;
             orderBy?: {
+                tableName: string;
                 columnName: string;
                 order: "ASC" | "DESC";
-                tableName: string;
             } | undefined;
         }, {
             path: string;
-            type: "PAGED" | "ARRAY" | "ONE";
+            type: "ONE" | "ARRAY" | "PAGED";
             name: string;
             table: string;
             joins: {
@@ -593,9 +1746,9 @@ declare const resturaZodSchema: z.ZodObject<{
             where: {
                 value?: string | number | undefined;
                 custom?: string | undefined;
-                columnName?: string | undefined;
                 tableName?: string | undefined;
-                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                 conjunction?: "AND" | "OR" | undefined;
             }[];
             method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
@@ -606,12 +1759,13 @@ declare const resturaZodSchema: z.ZodObject<{
                 name: string;
             }[];
             request: {
+                name: string;
+                required: boolean;
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
-                name: string;
-                required: boolean;
+                isNullable?: boolean | undefined;
             }[];
             response: {
                 name: string;
@@ -629,31 +1783,31 @@ declare const resturaZodSchema: z.ZodObject<{
                     where: {
                         value?: string | number | undefined;
                         custom?: string | undefined;
-                        columnName?: string | undefined;
                         tableName?: string | undefined;
-                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                        columnName?: string | undefined;
+                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                         conjunction?: "AND" | "OR" | undefined;
                     }[];
                     properties: any[];
                     groupBy?: {
-                        columnName: string;
                         tableName: string;
+                        columnName: string;
                     } | undefined;
                     orderBy?: {
+                        tableName: string;
                         columnName: string;
                         order: "ASC" | "DESC";
-                        tableName: string;
                     } | undefined;
                 } | undefined;
             }[];
             groupBy?: {
-                columnName: string;
                 tableName: string;
+                columnName: string;
             } | undefined;
             orderBy?: {
+                tableName: string;
                 columnName: string;
                 order: "ASC" | "DESC";
-                tableName: string;
             } | undefined;
         }>, z.ZodObject<z.objectUtil.extendShape<{
             method: z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>;
@@ -668,6 +1822,7 @@ declare const resturaZodSchema: z.ZodObject<{
             request: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 name: z.ZodString;
                 required: z.ZodBoolean;
+                isNullable: z.ZodOptional<z.ZodBoolean>;
                 validator: z.ZodArray<z.ZodObject<{
                     type: z.ZodEnum<["TYPE_CHECK", "MIN", "MAX", "ONE_OF"]>;
                     value: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>;
@@ -679,19 +1834,21 @@ declare const resturaZodSchema: z.ZodObject<{
                     value: string | number | string[] | number[];
                 }>, "many">;
             }, "strict", z.ZodTypeAny, {
+                name: string;
+                required: boolean;
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
+                isNullable?: boolean | undefined;
+            }, {
                 name: string;
                 required: boolean;
-            }, {
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
-                name: string;
-                required: boolean;
+                isNullable?: boolean | undefined;
             }>, "many">>;
             table: z.ZodUndefined;
             joins: z.ZodUndefined;
@@ -709,12 +1866,13 @@ declare const resturaZodSchema: z.ZodObject<{
             joins?: undefined;
             assignments?: undefined;
             request?: {
+                name: string;
+                required: boolean;
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
-                name: string;
-                required: boolean;
+                isNullable?: boolean | undefined;
             }[] | undefined;
             requestType?: string | undefined;
             fileUploadType?: "SINGLE" | "MULTIPLE" | undefined;
@@ -730,12 +1888,13 @@ declare const resturaZodSchema: z.ZodObject<{
             joins?: undefined;
             assignments?: undefined;
             request?: {
+                name: string;
+                required: boolean;
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
-                name: string;
-                required: boolean;
+                isNullable?: boolean | undefined;
             }[] | undefined;
             requestType?: string | undefined;
             fileUploadType?: "SINGLE" | "MULTIPLE" | undefined;
@@ -746,7 +1905,7 @@ declare const resturaZodSchema: z.ZodObject<{
         baseUrl: string;
         routes: ({
             path: string;
-            type: "PAGED" | "ARRAY" | "ONE";
+            type: "ONE" | "ARRAY" | "PAGED";
             name: string;
             table: string;
             joins: {
@@ -760,9 +1919,9 @@ declare const resturaZodSchema: z.ZodObject<{
             where: {
                 value?: string | number | undefined;
                 custom?: string | undefined;
-                columnName?: string | undefined;
                 tableName?: string | undefined;
-                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                 conjunction?: "AND" | "OR" | undefined;
             }[];
             method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
@@ -773,12 +1932,13 @@ declare const resturaZodSchema: z.ZodObject<{
                 name: string;
             }[];
             request: {
+                name: string;
+                required: boolean;
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
-                name: string;
-                required: boolean;
+                isNullable?: boolean | undefined;
             }[];
             response: {
                 name: string;
@@ -796,31 +1956,31 @@ declare const resturaZodSchema: z.ZodObject<{
                     where: {
                         value?: string | number | undefined;
                         custom?: string | undefined;
-                        columnName?: string | undefined;
                         tableName?: string | undefined;
-                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                        columnName?: string | undefined;
+                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                         conjunction?: "AND" | "OR" | undefined;
                     }[];
                     properties: any[];
                     groupBy?: {
-                        columnName: string;
                         tableName: string;
+                        columnName: string;
                     } | undefined;
                     orderBy?: {
+                        tableName: string;
                         columnName: string;
                         order: "ASC" | "DESC";
-                        tableName: string;
                     } | undefined;
                 } | undefined;
             }[];
             groupBy?: {
-                columnName: string;
                 tableName: string;
+                columnName: string;
             } | undefined;
             orderBy?: {
+                tableName: string;
                 columnName: string;
                 order: "ASC" | "DESC";
-                tableName: string;
             } | undefined;
         } | {
             path: string;
@@ -834,12 +1994,13 @@ declare const resturaZodSchema: z.ZodObject<{
             joins?: undefined;
             assignments?: undefined;
             request?: {
+                name: string;
+                required: boolean;
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
-                name: string;
-                required: boolean;
+                isNullable?: boolean | undefined;
             }[] | undefined;
             requestType?: string | undefined;
             fileUploadType?: "SINGLE" | "MULTIPLE" | undefined;
@@ -850,7 +2011,7 @@ declare const resturaZodSchema: z.ZodObject<{
         baseUrl: string;
         routes: ({
             path: string;
-            type: "PAGED" | "ARRAY" | "ONE";
+            type: "ONE" | "ARRAY" | "PAGED";
             name: string;
             table: string;
             joins: {
@@ -864,9 +2025,9 @@ declare const resturaZodSchema: z.ZodObject<{
             where: {
                 value?: string | number | undefined;
                 custom?: string | undefined;
-                columnName?: string | undefined;
                 tableName?: string | undefined;
-                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                 conjunction?: "AND" | "OR" | undefined;
             }[];
             method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
@@ -877,12 +2038,13 @@ declare const resturaZodSchema: z.ZodObject<{
                 name: string;
             }[];
             request: {
+                name: string;
+                required: boolean;
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
-                name: string;
-                required: boolean;
+                isNullable?: boolean | undefined;
             }[];
             response: {
                 name: string;
@@ -900,31 +2062,31 @@ declare const resturaZodSchema: z.ZodObject<{
                     where: {
                         value?: string | number | undefined;
                         custom?: string | undefined;
-                        columnName?: string | undefined;
                         tableName?: string | undefined;
-                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                        columnName?: string | undefined;
+                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                         conjunction?: "AND" | "OR" | undefined;
                     }[];
                     properties: any[];
                     groupBy?: {
-                        columnName: string;
                         tableName: string;
+                        columnName: string;
                     } | undefined;
                     orderBy?: {
+                        tableName: string;
                         columnName: string;
                         order: "ASC" | "DESC";
-                        tableName: string;
                     } | undefined;
                 } | undefined;
             }[];
             groupBy?: {
-                columnName: string;
                 tableName: string;
+                columnName: string;
             } | undefined;
             orderBy?: {
+                tableName: string;
                 columnName: string;
                 order: "ASC" | "DESC";
-                tableName: string;
             } | undefined;
         } | {
             path: string;
@@ -938,12 +2100,13 @@ declare const resturaZodSchema: z.ZodObject<{
             joins?: undefined;
             assignments?: undefined;
             request?: {
+                name: string;
+                required: boolean;
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
-                name: string;
-                required: boolean;
+                isNullable?: boolean | undefined;
             }[] | undefined;
             requestType?: string | undefined;
             fileUploadType?: "SINGLE" | "MULTIPLE" | undefined;
@@ -951,17 +2114,17 @@ declare const resturaZodSchema: z.ZodObject<{
     }>, "many">;
     globalParams: z.ZodArray<z.ZodString, "many">;
     roles: z.ZodArray<z.ZodString, "many">;
-    customTypes: z.ZodString;
+    customTypes: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
     roles: string[];
     database: {
         name: string;
         roles: string[];
         columns: {
-            type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "JSON" | "LONGBLOB" | "ENUM" | "DATETIME";
+            type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "JSON" | "JSONB" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "LONGBLOB" | "ENUM" | "DATETIME";
             name: string;
-            roles: string[];
             isNullable: boolean;
+            roles: string[];
             length?: number | undefined;
             value?: string | undefined;
             default?: string | undefined;
@@ -989,6 +2152,7 @@ declare const resturaZodSchema: z.ZodObject<{
             name: string;
             check: string;
         }[];
+        notify?: string[] | "ALL" | undefined;
     }[];
     endpoints: {
         name: string;
@@ -996,7 +2160,7 @@ declare const resturaZodSchema: z.ZodObject<{
         baseUrl: string;
         routes: ({
             path: string;
-            type: "PAGED" | "ARRAY" | "ONE";
+            type: "ONE" | "ARRAY" | "PAGED";
             name: string;
             table: string;
             joins: {
@@ -1010,9 +2174,9 @@ declare const resturaZodSchema: z.ZodObject<{
             where: {
                 value?: string | number | undefined;
                 custom?: string | undefined;
-                columnName?: string | undefined;
                 tableName?: string | undefined;
-                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                 conjunction?: "AND" | "OR" | undefined;
             }[];
             method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
@@ -1023,12 +2187,13 @@ declare const resturaZodSchema: z.ZodObject<{
                 name: string;
             }[];
             request: {
+                name: string;
+                required: boolean;
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
-                name: string;
-                required: boolean;
+                isNullable?: boolean | undefined;
             }[];
             response: {
                 name: string;
@@ -1046,31 +2211,31 @@ declare const resturaZodSchema: z.ZodObject<{
                     where: {
                         value?: string | number | undefined;
                         custom?: string | undefined;
-                        columnName?: string | undefined;
                         tableName?: string | undefined;
-                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                        columnName?: string | undefined;
+                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                         conjunction?: "AND" | "OR" | undefined;
                     }[];
                     properties: any[];
                     groupBy?: {
-                        columnName: string;
                         tableName: string;
+                        columnName: string;
                     } | undefined;
                     orderBy?: {
+                        tableName: string;
                         columnName: string;
                         order: "ASC" | "DESC";
-                        tableName: string;
                     } | undefined;
                 } | undefined;
             }[];
             groupBy?: {
-                columnName: string;
                 tableName: string;
+                columnName: string;
             } | undefined;
             orderBy?: {
+                tableName: string;
                 columnName: string;
                 order: "ASC" | "DESC";
-                tableName: string;
             } | undefined;
         } | {
             path: string;
@@ -1084,29 +2249,30 @@ declare const resturaZodSchema: z.ZodObject<{
             joins?: undefined;
             assignments?: undefined;
             request?: {
+                name: string;
+                required: boolean;
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
-                name: string;
-                required: boolean;
+                isNullable?: boolean | undefined;
             }[] | undefined;
             requestType?: string | undefined;
             fileUploadType?: "SINGLE" | "MULTIPLE" | undefined;
         })[];
     }[];
     globalParams: string[];
-    customTypes: string;
+    customTypes: string[];
 }, {
     roles: string[];
     database: {
         name: string;
         roles: string[];
         columns: {
-            type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "JSON" | "LONGBLOB" | "ENUM" | "DATETIME";
+            type: "SMALLINT" | "INTEGER" | "BIGINT" | "DECIMAL" | "NUMERIC" | "REAL" | "DOUBLE PRECISION" | "SERIAL" | "BIGSERIAL" | "CHAR" | "VARCHAR" | "TEXT" | "BYTEA" | "DATE" | "TIMESTAMP" | "TIMESTAMPTZ" | "TIME" | "INTERVAL" | "JSON" | "JSONB" | "BOOLEAN" | "TINYINT" | "MEDIUMINT" | "FLOAT" | "DOUBLE" | "TINYTEXT" | "TINYBLOB" | "BLOB" | "MEDIUMTEXT" | "MEDIUMBLOB" | "LONGTEXT" | "LONGBLOB" | "ENUM" | "DATETIME";
             name: string;
-            roles: string[];
             isNullable: boolean;
+            roles: string[];
             length?: number | undefined;
             value?: string | undefined;
             default?: string | undefined;
@@ -1134,6 +2300,7 @@ declare const resturaZodSchema: z.ZodObject<{
             name: string;
             check: string;
         }[];
+        notify?: string[] | "ALL" | undefined;
     }[];
     endpoints: {
         name: string;
@@ -1141,7 +2308,7 @@ declare const resturaZodSchema: z.ZodObject<{
         baseUrl: string;
         routes: ({
             path: string;
-            type: "PAGED" | "ARRAY" | "ONE";
+            type: "ONE" | "ARRAY" | "PAGED";
             name: string;
             table: string;
             joins: {
@@ -1155,9 +2322,9 @@ declare const resturaZodSchema: z.ZodObject<{
             where: {
                 value?: string | number | undefined;
                 custom?: string | undefined;
-                columnName?: string | undefined;
                 tableName?: string | undefined;
-                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                columnName?: string | undefined;
+                operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                 conjunction?: "AND" | "OR" | undefined;
             }[];
             method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
@@ -1168,12 +2335,13 @@ declare const resturaZodSchema: z.ZodObject<{
                 name: string;
             }[];
             request: {
+                name: string;
+                required: boolean;
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
-                name: string;
-                required: boolean;
+                isNullable?: boolean | undefined;
             }[];
             response: {
                 name: string;
@@ -1191,31 +2359,31 @@ declare const resturaZodSchema: z.ZodObject<{
                     where: {
                         value?: string | number | undefined;
                         custom?: string | undefined;
-                        columnName?: string | undefined;
                         tableName?: string | undefined;
-                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | undefined;
+                        columnName?: string | undefined;
+                        operator?: "=" | "<" | ">" | "<=" | ">=" | "!=" | "LIKE" | "IN" | "NOT IN" | "STARTS WITH" | "ENDS WITH" | "IS" | "IS NOT" | undefined;
                         conjunction?: "AND" | "OR" | undefined;
                     }[];
                     properties: any[];
                     groupBy?: {
-                        columnName: string;
                         tableName: string;
+                        columnName: string;
                     } | undefined;
                     orderBy?: {
+                        tableName: string;
                         columnName: string;
                         order: "ASC" | "DESC";
-                        tableName: string;
                     } | undefined;
                 } | undefined;
             }[];
             groupBy?: {
-                columnName: string;
                 tableName: string;
+                columnName: string;
             } | undefined;
             orderBy?: {
+                tableName: string;
                 columnName: string;
                 order: "ASC" | "DESC";
-                tableName: string;
             } | undefined;
         } | {
             path: string;
@@ -1229,49 +2397,42 @@ declare const resturaZodSchema: z.ZodObject<{
             joins?: undefined;
             assignments?: undefined;
             request?: {
+                name: string;
+                required: boolean;
                 validator: {
                     type: "TYPE_CHECK" | "MIN" | "MAX" | "ONE_OF";
                     value: string | number | string[] | number[];
                 }[];
-                name: string;
-                required: boolean;
+                isNullable?: boolean | undefined;
             }[] | undefined;
             requestType?: string | undefined;
             fileUploadType?: "SINGLE" | "MULTIPLE" | undefined;
         })[];
     }[];
     globalParams: string[];
-    customTypes: string;
+    customTypes: string[];
 }>;
-type ResturaSchema = z.infer<typeof resturaZodSchema>;
-
-interface RequesterDetails {
-    role?: string;
-    host: string;
-    ipAddress: string;
-    [key: string]: string | number | undefined | null | boolean;
-}
-interface RsRequest<T = unknown> extends express.Request {
-    requesterDetails: RequesterDetails;
-    data: T;
-}
+type ResturaSchema = z.infer<typeof resturaSchema>;
 
-interface RoleWithOptionalUserDetails {
-    role: string;
-    [key: string]: string | number | boolean | object | null;
+declare abstract class PsqlConnection {
+    readonly instanceId: UUID;
+    protected constructor(instanceId?: UUID);
+    protected abstract query<R extends QueryResultRow = QueryResultRow, T extends Array<unknown> = unknown[]>(query: string, values?: QueryConfigValues<T>): Promise<QueryResult<R>>;
+    queryOne<T>(query: string, options: any[], requesterDetails: RequesterDetails): Promise<T>;
+    runQuery<T>(query: string, options: any[], requesterDetails: RequesterDetails): Promise<T[]>;
+    private logSqlStatement;
 }
-type AuthenticateHandler = (req: RsRequest<unknown>, onValid: (userDetails: RoleWithOptionalUserDetails) => void, onReject: (errorMessage: string) => void) => Promise<void>;
 
-declare class PsqlPool {
+declare class PsqlPool extends PsqlConnection {
     poolConfig: PoolConfig;
     pool: Pool;
     constructor(poolConfig: PoolConfig);
-    queryOne(query: string, options: Array<any>): Promise<any>;
-    runQuery(query: string, options: any[]): Promise<any[]>;
+    protected query<R extends QueryResultRow = QueryResultRow, T extends Array<unknown> = unknown[]>(query: string, values?: QueryConfigValues<T>): Promise<QueryResult<R>>;
 }
 
 declare class ResturaEngine {
     resturaConfig: ResturaConfigSchema;
+    private multerCommonUpload;
     private resturaRouter;
     private publicEndpoints;
     private expressApp;
@@ -1321,6 +2482,12 @@ declare class ResturaEngine {
      * @returns A promise that resolves when the model has been successfully written to the output file.
      */
     generateModelFromSchema(outputFile: string, providedSchema: ResturaSchema): Promise<void>;
+    /**
+     * Generates the ambient module declaration for Restura global types and writes it to the specified output file.
+     * These types are used sometimes in the CustomTypes
+     * @param outputFile
+     */
+    generateResturaGlobalTypes(outputFile: string): void;
     /**
      * Retrieves the latest file system schema for Restura.
      *
@@ -1328,20 +2495,6 @@ declare class ResturaEngine {
      * @throws {Error} If the schema file is missing or the schema is not valid.
      */
     getLatestFileSystemSchema(): Promise<ResturaSchema>;
-    /**
-     * Asynchronously generates and retrieves hashes for the provided schema and related generated files.
-     *
-     * @param providedSchema - The schema for which hashes need to be generated.
-     * @returns A promise that resolves to an object containing:
-     * - `schemaHash`: The hash of the provided schema.
-     * - `apiCreatedSchemaHash`: The hash extracted from the generated `api.d.ts` file.
-     * - `modelCreatedSchemaHash`: The hash extracted from the generated `models.d.ts` file.
-     */
-    getHashes(providedSchema: ResturaSchema): Promise<{
-        schemaHash: string;
-        apiCreatedSchemaHash: string;
-        modelCreatedSchemaHash: string;
-    }>;
     private reloadEndpoints;
     private validateGeneratedTypesFolder;
     private resturaAuthentication;
@@ -1350,9 +2503,10 @@ declare class ResturaEngine {
     private updateTypes;
     private getSchema;
     private getSchemaAndTypes;
+    private getMulterFilesIfAny;
     private executeRouteLogic;
     private isCustomRoute;
-    private generateHashForSchema;
+    private runCustomRouteLogic;
     private storeFileSystemSchema;
     private resetPublicEndpoints;
     private validateAuthorization;
@@ -1360,4 +2514,112 @@ declare class ResturaEngine {
 }
 declare const restura: ResturaEngine;
 
-export { PsqlPool, logger, restura };
+declare const filterPsqlParser: peg.Parser;
+
+declare abstract class SqlEngine {
+    runQueryForRoute(req: RsRequest<unknown>, routeData: StandardRouteData, schema: ResturaSchema): Promise<DynamicObject | any[] | boolean>;
+    protected getTableSchema(schema: ResturaSchema, tableName: string): TableData;
+    protected doesRoleHavePermissionToColumn(role: string | undefined | null, schema: ResturaSchema, item: ResponseData, joins: JoinData[]): boolean;
+    protected doesRoleHavePermissionToTable(userRole: string | undefined, schema: ResturaSchema, tableName: string): boolean;
+    protected abstract generateJoinStatements(req: RsRequest<unknown>, joins: JoinData[], baseTable: string, routeData: StandardRouteData, schema: ResturaSchema, userRole: string | undefined, sqlParams: string[]): string;
+    protected abstract generateGroupBy(routeData: StandardRouteData): string;
+    protected abstract generateOrderBy(req: RsRequest<unknown>, routeData: StandardRouteData): string;
+    protected abstract generateWhereClause(req: RsRequest<unknown>, where: WhereData[], routeData: StandardRouteData, sqlParams: string[]): string;
+    protected replaceParamKeywords(value: string | number, routeData: RouteData, req: RsRequest<unknown>, sqlParams: string[]): string | number;
+    protected replaceLocalParamKeywords(value: string | number, routeData: RouteData, req: RsRequest<unknown>, sqlParams: string[]): string | number;
+    protected replaceGlobalParamKeywords(value: string | number, routeData: RouteData, req: RsRequest<unknown>, sqlParams: string[]): string | number;
+    abstract generateDatabaseSchemaFromSchema(schema: ResturaSchema): string;
+    abstract diffDatabaseToSchema(schema: ResturaSchema): Promise<string>;
+    protected abstract createNestedSelect(req: RsRequest<unknown>, schema: ResturaSchema, item: ResponseData, routeData: StandardRouteData, userRole: string | undefined, sqlParams: string[]): string;
+    protected abstract executeCreateRequest(req: RsRequest<unknown>, routeData: StandardRouteData, schema: ResturaSchema): Promise<DynamicObject>;
+    protected abstract executeGetRequest(req: RsRequest<unknown>, routeData: StandardRouteData, schema: ResturaSchema): Promise<DynamicObject | any[]>;
+    protected abstract executeUpdateRequest(req: RsRequest<unknown>, routeData: StandardRouteData, schema: ResturaSchema): Promise<DynamicObject>;
+    protected abstract executeDeleteRequest(req: RsRequest<unknown>, routeData: StandardRouteData, schema: ResturaSchema): Promise<boolean>;
+}
+
+declare class PsqlEngine extends SqlEngine {
+    private psqlConnectionPool;
+    setupTriggerListeners: Promise<void> | undefined;
+    private triggerClient;
+    constructor(psqlConnectionPool: PsqlPool, shouldListenForDbTriggers?: boolean);
+    close(): Promise<void>;
+    private setupPgReturnTypes;
+    private listenForDbTriggers;
+    private handleTrigger;
+    createDatabaseFromSchema(schema: ResturaSchema, connection: PsqlPool): Promise<string>;
+    generateDatabaseSchemaFromSchema(schema: ResturaSchema): string;
+    private getScratchPool;
+    diffDatabaseToSchema(schema: ResturaSchema): Promise<string>;
+    protected createNestedSelect(req: RsRequest<unknown>, schema: ResturaSchema, item: ResponseData, routeData: StandardRouteData, userRole: string | undefined, sqlParams: string[]): string;
+    protected executeCreateRequest(req: RsRequest<unknown>, routeData: StandardRouteData, schema: ResturaSchema): Promise<DynamicObject>;
+    protected executeGetRequest(req: RsRequest<unknown>, routeData: StandardRouteData, schema: ResturaSchema): Promise<DynamicObject | any[]>;
+    protected executeUpdateRequest(req: RsRequest<unknown>, routeData: StandardRouteData, schema: ResturaSchema): Promise<DynamicObject>;
+    protected executeDeleteRequest(req: RsRequest<unknown>, routeData: StandardRouteData, schema: ResturaSchema): Promise<boolean>;
+    protected generateJoinStatements(req: RsRequest<unknown>, joins: JoinData[], baseTable: string, routeData: StandardRouteData | CustomRouteData, schema: ResturaSchema, userRole: string | undefined, sqlParams: string[]): string;
+    protected generateGroupBy(routeData: StandardRouteData): string;
+    protected generateOrderBy(req: RsRequest<unknown>, routeData: StandardRouteData): string;
+    protected generateWhereClause(req: RsRequest<unknown>, where: WhereData[], routeData: StandardRouteData | CustomRouteData, sqlParams: string[]): string;
+    private createUpdateTrigger;
+    private createDeleteTrigger;
+    private createInsertTriggers;
+    private schemaToPsqlType;
+}
+
+declare class PsqlTransaction extends PsqlConnection {
+    clientConfig: ClientConfig;
+    client: Client;
+    private beginTransactionPromise;
+    private connectPromise;
+    constructor(clientConfig: ClientConfig, instanceId?: UUID);
+    close(): Promise<void>;
+    private beginTransaction;
+    rollback(): Promise<QueryResult<QueryResultRow>>;
+    commit(): Promise<QueryResult<QueryResultRow>>;
+    release(): Promise<void>;
+    protected query<R extends QueryResultRow = QueryResultRow, T extends Array<unknown> = unknown[]>(query: string, values?: QueryConfigValues<T>): Promise<QueryResult<R>>;
+}
+
+/**
+ * This method does a couple of things:
+ * 1. It escapes the column name to prevent SQL injection by removing any double quotes.
+ * 2. It wraps the column name in double quotes to prevent any issues with reserved words or casing.
+ * 3. It replaces any periods in the column name with a period wrapped in double quotes to prevent any issues with schema names.
+ * NOTE: I looked into using pg-format ident() method but that will strip the double quotes when not needed.
+ * @param columnName
+ * @returns
+ */
+declare function escapeColumnName(columnName: string | undefined): string;
+/**
+ * Converts a query with question marks to a query with numbered parameters,
+ * however it ignores question marks inside single or double quotes.
+ * @param query PostgreSQL query with question marks
+ * @returns A string with numbered parameters such as $1, $2 in replacement of question marks
+ */
+declare function questionMarksToOrderedParams(query: string): string;
+/**
+ * Creates a query to insert an object into a table.
+ * @param table Table name to insert the object into
+ * @param obj  Data to insert into the table
+ * @returns the query to insert the object into the table
+ */
+declare function insertObjectQuery(table: string, obj: DynamicObject): string;
+/**
+ * Creates a query to update an object in a table.
+ * @param table Table name to update the object in
+ * @param obj Data to update in the table
+ * @param whereStatement Where clause to determine which rows to update
+ * @returns the query to update the object in the table
+ */
+declare function updateObjectQuery(table: string, obj: DynamicObject, whereStatement: string): string;
+declare function isValueNumber(value: unknown): value is number;
+/**
+ * This method is used to format a query and escape user input.
+ * Use this with the SQL tag to escape user input. For example:
+ * SQL`UPDATE "USER" SET "firstName" = ${firstName}, "isActive" = ${isActive} WHERE "id" = ${id} RETURNING *`
+ * @param strings template strings array
+ * @param values values to escape
+ * @returns An escaped query with user input
+ */
+declare function SQL(strings: TemplateStringsArray, ...values: unknown[]): string;
+
+export { type ActionColumnChangeData, type ActionColumnChangeFilter, type ActionRowDeleteData, type ActionRowDeleteFilter, type ActionRowInsertData, type ActionRowInsertFilter, type ApiMethod, type AsyncExpressApplication, type AuthenticateHandler, type AuthenticationUserDetails, type ConjunctionTypes, type DatabaseActionData, type DynamicObject, type ErrorCode, type EventType, HtmlStatusCodes, type MatchTypes, type MutationType, type PageQuery, PsqlConnection, PsqlEngine, PsqlPool, PsqlTransaction, type QueryMetadata, type RequesterDetails, RsError, type RsErrorData, type RsErrorInternalData, type RsHeaders, type RsPagedResponseData, type RsRequest, type RsResponse, type RsResponseData, type RsRouteHandler, SQL, type SchemaChangeValue, type SchemaPreview, type SqlMutationData, type StandardOrderTypes, type TriggerResult, type ValidAuthenticationCallback, escapeColumnName, eventManager, filterPsqlParser, insertObjectQuery, isValueNumber, logger, questionMarksToOrderedParams, restura, updateObjectQuery };