@graphoria/server 0.1.0

package/dist/src/types/zod/configuration.d.ts

@@ -0,0 +1,1278 @@
+import { z } from "zod";
+export declare const ConfigurationZod: z.ZodPipe<z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    tokenStrategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        jwt: "jwt";
+        paseto_local: "paseto_local";
+        paseto_public: "paseto_public";
+    }>>>;
+    databases: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        enabled: z.ZodBoolean;
+        type: z.ZodUnion<readonly [z.ZodLiteral<"mssql">, z.ZodLiteral<"pg">, z.ZodLiteral<"mysql">]>;
+        connection: z.ZodObject<{
+            host: z.ZodString;
+            port: z.ZodNumber;
+            user: z.ZodString;
+            password: z.ZodString;
+            database: z.ZodString;
+        }, z.core.$strip>;
+        fieldNaming: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        repository: z.ZodOptional<z.ZodCustom<import("../../config").CustomRepositoryFactory<import("./db").DatabaseType>, import("../../config").CustomRepositoryFactory<import("./db").DatabaseType>>>;
+        onConnect: z.ZodOptional<z.ZodCustom<import("../../config").OnConnectHandler<import("./db").DatabaseType>, import("../../config").OnConnectHandler<import("./db").DatabaseType>>>;
+        schema: z.ZodOptional<z.ZodObject<{
+            database: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCatch<z.ZodDefault<z.ZodOptional<z.ZodObject<{
+                columns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    dataType: z.ZodString;
+                    isNullable: z.ZodBoolean;
+                    description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    virtual: z.ZodOptional<z.ZodBoolean>;
+                    function: z.ZodOptional<z.ZodString>;
+                    params: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    expression: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>>;
+                relationships: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    schema: z.ZodString;
+                    name: z.ZodString;
+                    columns: z.ZodArray<z.ZodObject<{
+                        source: z.ZodString;
+                        target: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>>>;
+                description: z.ZodOptional<z.ZodString>;
+                columnDescriptions: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+            }, z.core.$strip>>>>>>>;
+            excludedTables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>>;
+        connectionOptions: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            max: z.ZodDefault<z.ZodNumber>;
+            idleTimeout: z.ZodDefault<z.ZodNumber>;
+            connectionTimeout: z.ZodDefault<z.ZodNumber>;
+            maxLifetime: z.ZodDefault<z.ZodNumber>;
+            tls: z.ZodDefault<z.ZodBoolean>;
+            prepare: z.ZodDefault<z.ZodBoolean>;
+            bigint: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            pool: z.ZodDefault<z.ZodObject<{
+                max: z.ZodDefault<z.ZodNumber>;
+                min: z.ZodDefault<z.ZodNumber>;
+                idleTimeout: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            connectionTimeout: z.ZodDefault<z.ZodNumber>;
+            requestTimeout: z.ZodDefault<z.ZodNumber>;
+            encrypt: z.ZodDefault<z.ZodBoolean>;
+            trustServerCertificate: z.ZodDefault<z.ZodBoolean>;
+            trustedConnection: z.ZodDefault<z.ZodBoolean>;
+            parseJSON: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>>>;
+    queues: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodPipe<z.ZodObject<{
+        name: z.ZodString;
+        autoSetup: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        reconnect: z.ZodOptional<z.ZodObject<{
+            initialDelay: z.ZodDefault<z.ZodNumber>;
+            maxDelay: z.ZodDefault<z.ZodNumber>;
+            multiplier: z.ZodDefault<z.ZodNumber>;
+            maxAttempts: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        publishers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            topic: z.ZodString;
+            routingKey: z.ZodOptional<z.ZodString>;
+            persistent: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>>>;
+        subscribers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            topic: z.ZodString;
+            pattern: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            queue: z.ZodOptional<z.ZodString>;
+            group: z.ZodOptional<z.ZodString>;
+            durable: z.ZodOptional<z.ZodBoolean>;
+            autoDelete: z.ZodOptional<z.ZodBoolean>;
+            handler: z.ZodOptional<z.ZodCustom<import("./queue").SubscriberHandler, import("./queue").SubscriberHandler>>;
+        }, z.core.$strip>>>>;
+        topics: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                headers: "headers";
+                topic: "topic";
+                direct: "direct";
+                fanout: "fanout";
+            }>>>;
+            durable: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            autoDelete: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strip>>>>;
+        type: z.ZodLiteral<"rabbitmq">;
+        connection: z.ZodUnion<readonly [z.ZodURL, z.ZodObject<{
+            hostname: z.ZodDefault<z.ZodString>;
+            port: z.ZodDefault<z.ZodNumber>;
+            username: z.ZodOptional<z.ZodString>;
+            password: z.ZodOptional<z.ZodString>;
+            vhost: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodTransform<{
+        name: string;
+        autoSetup: boolean;
+        enabled: boolean;
+        publishers: Record<string, {
+            topic: string;
+            persistent: boolean;
+            routingKey?: string | undefined;
+            headers?: Record<string, string> | undefined;
+        }>;
+        subscribers: Record<string, {
+            topic: string;
+            pattern: string;
+            queue?: string | undefined;
+            group?: string | undefined;
+            durable?: boolean | undefined;
+            autoDelete?: boolean | undefined;
+            handler?: import("./queue").SubscriberHandler | undefined;
+        }>;
+        topics: Record<string, {
+            type: "headers" | "topic" | "direct" | "fanout";
+            durable: boolean;
+            autoDelete: boolean;
+        }>;
+        type: "rabbitmq";
+        connection: string | {
+            hostname: string;
+            port: number;
+            vhost: string;
+            username?: string | undefined;
+            password?: string | undefined;
+        };
+        reconnect?: {
+            initialDelay: number;
+            maxDelay: number;
+            multiplier: number;
+            maxAttempts: number;
+        } | undefined;
+    } & {
+        exchanges: Array<{
+            name: string;
+            type: "topic" | "direct" | "fanout" | "headers";
+            options?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            publishers: Array<{
+                name: string;
+                resolverName: string;
+                routingKey: string;
+                options?: {
+                    persistent?: boolean;
+                    headers?: Record<string, string>;
+                };
+            }>;
+        }>;
+        queues: Array<{
+            name: string;
+            queue?: string;
+            groupId?: string;
+            bindings: Array<{
+                exchange: string;
+                pattern: string;
+            }>;
+            queueOptions?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            handler?: import("./queue").SubscriberHandler;
+        }>;
+    }, {
+        name: string;
+        autoSetup: boolean;
+        enabled: boolean;
+        publishers: Record<string, {
+            topic: string;
+            persistent: boolean;
+            routingKey?: string | undefined;
+            headers?: Record<string, string> | undefined;
+        }>;
+        subscribers: Record<string, {
+            topic: string;
+            pattern: string;
+            queue?: string | undefined;
+            group?: string | undefined;
+            durable?: boolean | undefined;
+            autoDelete?: boolean | undefined;
+            handler?: import("./queue").SubscriberHandler | undefined;
+        }>;
+        topics: Record<string, {
+            type: "headers" | "topic" | "direct" | "fanout";
+            durable: boolean;
+            autoDelete: boolean;
+        }>;
+        type: "rabbitmq";
+        connection: string | {
+            hostname: string;
+            port: number;
+            vhost: string;
+            username?: string | undefined;
+            password?: string | undefined;
+        };
+        reconnect?: {
+            initialDelay: number;
+            maxDelay: number;
+            multiplier: number;
+            maxAttempts: number;
+        } | undefined;
+    }>>, z.ZodPipe<z.ZodObject<{
+        name: z.ZodString;
+        autoSetup: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        reconnect: z.ZodOptional<z.ZodObject<{
+            initialDelay: z.ZodDefault<z.ZodNumber>;
+            maxDelay: z.ZodDefault<z.ZodNumber>;
+            multiplier: z.ZodDefault<z.ZodNumber>;
+            maxAttempts: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        publishers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            topic: z.ZodString;
+            routingKey: z.ZodOptional<z.ZodString>;
+            persistent: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>>>;
+        subscribers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            topic: z.ZodString;
+            pattern: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            queue: z.ZodOptional<z.ZodString>;
+            group: z.ZodOptional<z.ZodString>;
+            durable: z.ZodOptional<z.ZodBoolean>;
+            autoDelete: z.ZodOptional<z.ZodBoolean>;
+            handler: z.ZodOptional<z.ZodCustom<import("./queue").SubscriberHandler, import("./queue").SubscriberHandler>>;
+        }, z.core.$strip>>>>;
+        topics: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                headers: "headers";
+                topic: "topic";
+                direct: "direct";
+                fanout: "fanout";
+            }>>>;
+            durable: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            autoDelete: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strip>>>>;
+        type: z.ZodLiteral<"kafka">;
+        connection: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            brokers: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+            clientId: z.ZodOptional<z.ZodString>;
+            ssl: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            sasl: z.ZodOptional<z.ZodObject<{
+                mechanism: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                    plain: "plain";
+                    "scram-sha-256": "scram-sha-256";
+                    "scram-sha-512": "scram-sha-512";
+                }>>>;
+                username: z.ZodString;
+                password: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodTransform<{
+        name: string;
+        autoSetup: boolean;
+        enabled: boolean;
+        publishers: Record<string, {
+            topic: string;
+            persistent: boolean;
+            routingKey?: string | undefined;
+            headers?: Record<string, string> | undefined;
+        }>;
+        subscribers: Record<string, {
+            topic: string;
+            pattern: string;
+            queue?: string | undefined;
+            group?: string | undefined;
+            durable?: boolean | undefined;
+            autoDelete?: boolean | undefined;
+            handler?: import("./queue").SubscriberHandler | undefined;
+        }>;
+        topics: Record<string, {
+            type: "headers" | "topic" | "direct" | "fanout";
+            durable: boolean;
+            autoDelete: boolean;
+        }>;
+        type: "kafka";
+        connection: string | {
+            brokers: string | string[];
+            ssl: boolean;
+            clientId?: string | undefined;
+            sasl?: {
+                mechanism: "plain" | "scram-sha-256" | "scram-sha-512";
+                username: string;
+                password: string;
+            } | undefined;
+        };
+        reconnect?: {
+            initialDelay: number;
+            maxDelay: number;
+            multiplier: number;
+            maxAttempts: number;
+        } | undefined;
+    } & {
+        exchanges: Array<{
+            name: string;
+            type: "topic" | "direct" | "fanout" | "headers";
+            options?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            publishers: Array<{
+                name: string;
+                resolverName: string;
+                routingKey: string;
+                options?: {
+                    persistent?: boolean;
+                    headers?: Record<string, string>;
+                };
+            }>;
+        }>;
+        queues: Array<{
+            name: string;
+            queue?: string;
+            groupId?: string;
+            bindings: Array<{
+                exchange: string;
+                pattern: string;
+            }>;
+            queueOptions?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            handler?: import("./queue").SubscriberHandler;
+        }>;
+    }, {
+        name: string;
+        autoSetup: boolean;
+        enabled: boolean;
+        publishers: Record<string, {
+            topic: string;
+            persistent: boolean;
+            routingKey?: string | undefined;
+            headers?: Record<string, string> | undefined;
+        }>;
+        subscribers: Record<string, {
+            topic: string;
+            pattern: string;
+            queue?: string | undefined;
+            group?: string | undefined;
+            durable?: boolean | undefined;
+            autoDelete?: boolean | undefined;
+            handler?: import("./queue").SubscriberHandler | undefined;
+        }>;
+        topics: Record<string, {
+            type: "headers" | "topic" | "direct" | "fanout";
+            durable: boolean;
+            autoDelete: boolean;
+        }>;
+        type: "kafka";
+        connection: string | {
+            brokers: string | string[];
+            ssl: boolean;
+            clientId?: string | undefined;
+            sasl?: {
+                mechanism: "plain" | "scram-sha-256" | "scram-sha-512";
+                username: string;
+                password: string;
+            } | undefined;
+        };
+        reconnect?: {
+            initialDelay: number;
+            maxDelay: number;
+            multiplier: number;
+            maxAttempts: number;
+        } | undefined;
+    }>>], "type">>>>;
+    cron: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        pattern: z.ZodString;
+        query: z.ZodOptional<z.ZodString>;
+        variables: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+        timezone: z.ZodOptional<z.ZodString>;
+        paused: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        maxRuns: z.ZodOptional<z.ZodNumber>;
+        interval: z.ZodOptional<z.ZodNumber>;
+        startAt: z.ZodOptional<z.ZodString>;
+        stopAt: z.ZodOptional<z.ZodString>;
+        protect: z.ZodOptional<z.ZodBoolean>;
+        catchErrors: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        onTick: z.ZodOptional<z.ZodCustom<import("./cron").TickCallback<Record<string, unknown>>, import("./cron").TickCallback<Record<string, unknown>>>>;
+    }, z.core.$strip>>>>;
+    operations: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        query: z.ZodOptional<z.ZodString>;
+        handler: z.ZodOptional<z.ZodCustom<import("./operation").OperationHandler<any, any, any>, import("./operation").OperationHandler<any, any, any>>>;
+        input: z.ZodOptional<z.ZodCustom<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>>;
+        output: z.ZodOptional<z.ZodCustom<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>>;
+        hooks: z.ZodOptional<z.ZodObject<{
+            init: z.ZodOptional<z.ZodCustom<import("./operation").OperationInitHook<any>, import("./operation").OperationInitHook<any>>>;
+            beforeRequest: z.ZodOptional<z.ZodCustom<import("./operation").OperationBeforeRequestHook<any, any, any>, import("./operation").OperationBeforeRequestHook<any, any, any>>>;
+            afterRequest: z.ZodOptional<z.ZodCustom<import("./operation").OperationAfterRequestHook<any>, import("./operation").OperationAfterRequestHook<any>>>;
+        }, z.core.$strip>>;
+        rest: z.ZodOptional<z.ZodObject<{
+            path: z.ZodString;
+            method: z.ZodDefault<z.ZodEnum<{
+                GET: "GET";
+                POST: "POST";
+                PUT: "PUT";
+                PATCH: "PATCH";
+                DELETE: "DELETE";
+            }>>;
+            pathParams: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+            queryParams: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+            body: z.ZodOptional<z.ZodCustom<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+        }, z.core.$strip>>;
+        graphql: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        cache: z.ZodOptional<z.ZodObject<{
+            max: z.ZodOptional<z.ZodNumber>;
+            maxSize: z.ZodOptional<z.ZodNumber>;
+            ttl: z.ZodOptional<z.ZodNumber>;
+            allowStale: z.ZodOptional<z.ZodBoolean>;
+            updateAgeOnGet: z.ZodOptional<z.ZodBoolean>;
+            updateAgeOnHas: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            ttlAutopurge: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>>;
+    auth: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        database: z.ZodString;
+        schema: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        autoCreateTables: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        permissions: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDefault<z.ZodObject<{
+            tables: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"ALL">, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodObject<{
+                columns: z.ZodUnion<readonly [z.ZodLiteral<"ALL">, z.ZodArray<z.ZodString>]>;
+                filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+                orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    column: z.ZodString;
+                    direction: z.ZodEnum<{
+                        ASC: "ASC";
+                        DESC: "DESC";
+                        ASC_NULLS_FIRST: "ASC_NULLS_FIRST";
+                        ASC_NULLS_LAST: "ASC_NULLS_LAST";
+                        DESC_NULLS_FIRST: "DESC_NULLS_FIRST";
+                        DESC_NULLS_LAST: "DESC_NULLS_LAST";
+                    }>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>]>>]>>>;
+            storedProcedures: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"ALL">]>>>;
+            queues: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"ALL">]>>>;
+            operations: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"ALL">]>>>;
+            remoteSchemas: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"ALL">]>>>;
+            remoteREST: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<"ALL">]>>>;
+        }, z.core.$strip>>>>>;
+    }, z.core.$strip>>>, z.ZodTransform<{
+        permissions: {
+            [k: string]: {
+                tables: "ALL" | {
+                    [x: string]: {
+                        columns: "ALL" | string[];
+                    } & import("../configuration").TableFilter;
+                };
+                storedProcedures: string[] | "ALL";
+                queues: string[] | "ALL";
+                operations: string[] | "ALL";
+                remoteSchemas: string[] | "ALL";
+                remoteREST: string[] | "ALL";
+            };
+        };
+        enabled: boolean;
+        database: string;
+        schema: string;
+        autoCreateTables: boolean;
+    } | undefined, {
+        enabled: boolean;
+        database: string;
+        schema: string;
+        autoCreateTables: boolean;
+        permissions: Record<string, {
+            tables: string[] | "ALL" | Record<string, "ALL" | {
+                columns: string[] | "ALL";
+                filter?: Record<string, Record<string, unknown>> | undefined;
+                orderBy?: {
+                    column: string;
+                    direction: "ASC" | "DESC" | "ASC_NULLS_FIRST" | "ASC_NULLS_LAST" | "DESC_NULLS_FIRST" | "DESC_NULLS_LAST";
+                }[] | undefined;
+            }>;
+            storedProcedures: string[] | "ALL";
+            queues: string[] | "ALL";
+            operations: string[] | "ALL";
+            remoteSchemas: string[] | "ALL";
+            remoteREST: string[] | "ALL";
+        }>;
+    }>>;
+    remoteSchemas: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodURL;
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        prefix: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        forwardHeaders: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        introspection: z.ZodOptional<z.ZodObject<{
+            interval: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>>;
+    remoteREST: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodOptional<z.ZodURL>;
+        specUrl: z.ZodOptional<z.ZodURL>;
+        specPath: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        prefix: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        forwardHeaders: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>>>;
+    ai: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        endpoint: z.ZodDefault<z.ZodString>;
+        mcp: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodTransform<{
+    enabledDatabases: {
+        name: string;
+        enabled: boolean;
+        type: "mssql" | "mysql" | "pg";
+        connection: {
+            host: string;
+            port: number;
+            user: string;
+            password: string;
+            database: string;
+        };
+        fieldNaming: string;
+        repository?: import("../../config").CustomRepositoryFactory<import("./db").DatabaseType> | undefined;
+        onConnect?: import("../../config").OnConnectHandler<import("./db").DatabaseType> | undefined;
+        schema?: {
+            database: Record<string, {
+                columns: {
+                    name: string;
+                    dataType: string;
+                    isNullable: boolean;
+                    description: string | null;
+                    virtual?: boolean | undefined;
+                    function?: string | undefined;
+                    params?: string[] | undefined;
+                    expression?: string | undefined;
+                }[];
+                relationships: {
+                    schema: string;
+                    name: string;
+                    columns: {
+                        source: string;
+                        target: string;
+                    }[];
+                }[];
+                columnDescriptions: Record<string, string>;
+                description?: string | undefined;
+            }>;
+            excludedTables: string[];
+        } | undefined;
+        connectionOptions?: {
+            max: number;
+            idleTimeout: number;
+            connectionTimeout: number;
+            maxLifetime: number;
+            tls: boolean;
+            prepare: boolean;
+            bigint: boolean;
+        } | {
+            pool: {
+                max: number;
+                min: number;
+                idleTimeout: number;
+            };
+            connectionTimeout: number;
+            requestTimeout: number;
+            encrypt: boolean;
+            trustServerCertificate: boolean;
+            trustedConnection: boolean;
+            parseJSON: boolean;
+        } | undefined;
+    }[];
+    auth: {
+        databaseEntity: {
+            name: string;
+            enabled: boolean;
+            type: "mssql" | "mysql" | "pg";
+            connection: {
+                host: string;
+                port: number;
+                user: string;
+                password: string;
+                database: string;
+            };
+            fieldNaming: string;
+            repository?: import("../../config").CustomRepositoryFactory<import("./db").DatabaseType> | undefined;
+            onConnect?: import("../../config").OnConnectHandler<import("./db").DatabaseType> | undefined;
+            schema?: {
+                database: Record<string, {
+                    columns: {
+                        name: string;
+                        dataType: string;
+                        isNullable: boolean;
+                        description: string | null;
+                        virtual?: boolean | undefined;
+                        function?: string | undefined;
+                        params?: string[] | undefined;
+                        expression?: string | undefined;
+                    }[];
+                    relationships: {
+                        schema: string;
+                        name: string;
+                        columns: {
+                            source: string;
+                            target: string;
+                        }[];
+                    }[];
+                    columnDescriptions: Record<string, string>;
+                    description?: string | undefined;
+                }>;
+                excludedTables: string[];
+            } | undefined;
+            connectionOptions?: {
+                max: number;
+                idleTimeout: number;
+                connectionTimeout: number;
+                maxLifetime: number;
+                tls: boolean;
+                prepare: boolean;
+                bigint: boolean;
+            } | {
+                pool: {
+                    max: number;
+                    min: number;
+                    idleTimeout: number;
+                };
+                connectionTimeout: number;
+                requestTimeout: number;
+                encrypt: boolean;
+                trustServerCertificate: boolean;
+                trustedConnection: boolean;
+                parseJSON: boolean;
+            } | undefined;
+        };
+        permissions: {
+            [k: string]: {
+                tables: "ALL" | {
+                    [x: string]: {
+                        columns: "ALL" | string[];
+                    } & import("../configuration").TableFilter;
+                };
+                storedProcedures: string[] | "ALL";
+                queues: string[] | "ALL";
+                operations: string[] | "ALL";
+                remoteSchemas: string[] | "ALL";
+                remoteREST: string[] | "ALL";
+            };
+        };
+        enabled: boolean;
+        database: string;
+        schema: string;
+        autoCreateTables: boolean;
+    };
+    name: string;
+    version: string;
+    tokenStrategy: "jwt" | "paseto_local" | "paseto_public";
+    databases: {
+        name: string;
+        enabled: boolean;
+        type: "mssql" | "mysql" | "pg";
+        connection: {
+            host: string;
+            port: number;
+            user: string;
+            password: string;
+            database: string;
+        };
+        fieldNaming: string;
+        repository?: import("../../config").CustomRepositoryFactory<import("./db").DatabaseType> | undefined;
+        onConnect?: import("../../config").OnConnectHandler<import("./db").DatabaseType> | undefined;
+        schema?: {
+            database: Record<string, {
+                columns: {
+                    name: string;
+                    dataType: string;
+                    isNullable: boolean;
+                    description: string | null;
+                    virtual?: boolean | undefined;
+                    function?: string | undefined;
+                    params?: string[] | undefined;
+                    expression?: string | undefined;
+                }[];
+                relationships: {
+                    schema: string;
+                    name: string;
+                    columns: {
+                        source: string;
+                        target: string;
+                    }[];
+                }[];
+                columnDescriptions: Record<string, string>;
+                description?: string | undefined;
+            }>;
+            excludedTables: string[];
+        } | undefined;
+        connectionOptions?: {
+            max: number;
+            idleTimeout: number;
+            connectionTimeout: number;
+            maxLifetime: number;
+            tls: boolean;
+            prepare: boolean;
+            bigint: boolean;
+        } | {
+            pool: {
+                max: number;
+                min: number;
+                idleTimeout: number;
+            };
+            connectionTimeout: number;
+            requestTimeout: number;
+            encrypt: boolean;
+            trustServerCertificate: boolean;
+            trustedConnection: boolean;
+            parseJSON: boolean;
+        } | undefined;
+    }[];
+    queues: (({
+        name: string;
+        autoSetup: boolean;
+        enabled: boolean;
+        publishers: Record<string, {
+            topic: string;
+            persistent: boolean;
+            routingKey?: string | undefined;
+            headers?: Record<string, string> | undefined;
+        }>;
+        subscribers: Record<string, {
+            topic: string;
+            pattern: string;
+            queue?: string | undefined;
+            group?: string | undefined;
+            durable?: boolean | undefined;
+            autoDelete?: boolean | undefined;
+            handler?: import("./queue").SubscriberHandler | undefined;
+        }>;
+        topics: Record<string, {
+            type: "headers" | "topic" | "direct" | "fanout";
+            durable: boolean;
+            autoDelete: boolean;
+        }>;
+        type: "rabbitmq";
+        connection: string | {
+            hostname: string;
+            port: number;
+            vhost: string;
+            username?: string | undefined;
+            password?: string | undefined;
+        };
+        reconnect?: {
+            initialDelay: number;
+            maxDelay: number;
+            multiplier: number;
+            maxAttempts: number;
+        } | undefined;
+    } & {
+        exchanges: Array<{
+            name: string;
+            type: "topic" | "direct" | "fanout" | "headers";
+            options?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            publishers: Array<{
+                name: string;
+                resolverName: string;
+                routingKey: string;
+                options?: {
+                    persistent?: boolean;
+                    headers?: Record<string, string>;
+                };
+            }>;
+        }>;
+        queues: Array<{
+            name: string;
+            queue?: string;
+            groupId?: string;
+            bindings: Array<{
+                exchange: string;
+                pattern: string;
+            }>;
+            queueOptions?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            handler?: import("./queue").SubscriberHandler;
+        }>;
+    }) | ({
+        name: string;
+        autoSetup: boolean;
+        enabled: boolean;
+        publishers: Record<string, {
+            topic: string;
+            persistent: boolean;
+            routingKey?: string | undefined;
+            headers?: Record<string, string> | undefined;
+        }>;
+        subscribers: Record<string, {
+            topic: string;
+            pattern: string;
+            queue?: string | undefined;
+            group?: string | undefined;
+            durable?: boolean | undefined;
+            autoDelete?: boolean | undefined;
+            handler?: import("./queue").SubscriberHandler | undefined;
+        }>;
+        topics: Record<string, {
+            type: "headers" | "topic" | "direct" | "fanout";
+            durable: boolean;
+            autoDelete: boolean;
+        }>;
+        type: "kafka";
+        connection: string | {
+            brokers: string | string[];
+            ssl: boolean;
+            clientId?: string | undefined;
+            sasl?: {
+                mechanism: "plain" | "scram-sha-256" | "scram-sha-512";
+                username: string;
+                password: string;
+            } | undefined;
+        };
+        reconnect?: {
+            initialDelay: number;
+            maxDelay: number;
+            multiplier: number;
+            maxAttempts: number;
+        } | undefined;
+    } & {
+        exchanges: Array<{
+            name: string;
+            type: "topic" | "direct" | "fanout" | "headers";
+            options?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            publishers: Array<{
+                name: string;
+                resolverName: string;
+                routingKey: string;
+                options?: {
+                    persistent?: boolean;
+                    headers?: Record<string, string>;
+                };
+            }>;
+        }>;
+        queues: Array<{
+            name: string;
+            queue?: string;
+            groupId?: string;
+            bindings: Array<{
+                exchange: string;
+                pattern: string;
+            }>;
+            queueOptions?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            handler?: import("./queue").SubscriberHandler;
+        }>;
+    }))[];
+    cron: {
+        name: string;
+        pattern: string;
+        paused: boolean;
+        catchErrors: boolean;
+        query?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+        timezone?: string | undefined;
+        maxRuns?: number | undefined;
+        interval?: number | undefined;
+        startAt?: string | undefined;
+        stopAt?: string | undefined;
+        protect?: boolean | undefined;
+        context?: Record<string, any> | undefined;
+        onTick?: import("./cron").TickCallback<Record<string, unknown>> | undefined;
+    }[];
+    operations: Record<string, {
+        graphql: {
+            enabled: boolean;
+            name?: string | undefined;
+        };
+        description?: string | undefined;
+        query?: string | undefined;
+        handler?: import("./operation").OperationHandler<any, any, any> | undefined;
+        input?: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>> | undefined;
+        output?: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>> | undefined;
+        hooks?: {
+            init?: import("./operation").OperationInitHook<any> | undefined;
+            beforeRequest?: import("./operation").OperationBeforeRequestHook<any, any, any> | undefined;
+            afterRequest?: import("./operation").OperationAfterRequestHook<any> | undefined;
+        } | undefined;
+        rest?: {
+            path: string;
+            method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+            pathParams?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+            queryParams?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+            body?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+        } | undefined;
+        cache?: {
+            updateAgeOnHas: boolean;
+            ttlAutopurge: boolean;
+            max?: number | undefined;
+            maxSize?: number | undefined;
+            ttl?: number | undefined;
+            allowStale?: boolean | undefined;
+            updateAgeOnGet?: boolean | undefined;
+        } | undefined;
+    }>;
+    remoteSchemas: {
+        name: string;
+        url: string;
+        enabled: boolean;
+        timeout: number;
+        prefix?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        forwardHeaders?: string[] | undefined;
+        introspection?: {
+            interval: number;
+        } | undefined;
+    }[];
+    remoteREST: {
+        name: string;
+        enabled: boolean;
+        timeout: number;
+        url?: string | undefined;
+        specUrl?: string | undefined;
+        specPath?: string | undefined;
+        prefix?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        forwardHeaders?: string[] | undefined;
+    }[];
+    ai: {
+        enabled: boolean;
+        endpoint: string;
+        mcp: {
+            enabled: boolean;
+        };
+        systemPrompt?: string | undefined;
+    };
+}, {
+    name: string;
+    version: string;
+    tokenStrategy: "jwt" | "paseto_local" | "paseto_public";
+    databases: {
+        name: string;
+        enabled: boolean;
+        type: "mssql" | "mysql" | "pg";
+        connection: {
+            host: string;
+            port: number;
+            user: string;
+            password: string;
+            database: string;
+        };
+        fieldNaming: string;
+        repository?: import("../../config").CustomRepositoryFactory<import("./db").DatabaseType> | undefined;
+        onConnect?: import("../../config").OnConnectHandler<import("./db").DatabaseType> | undefined;
+        schema?: {
+            database: Record<string, {
+                columns: {
+                    name: string;
+                    dataType: string;
+                    isNullable: boolean;
+                    description: string | null;
+                    virtual?: boolean | undefined;
+                    function?: string | undefined;
+                    params?: string[] | undefined;
+                    expression?: string | undefined;
+                }[];
+                relationships: {
+                    schema: string;
+                    name: string;
+                    columns: {
+                        source: string;
+                        target: string;
+                    }[];
+                }[];
+                columnDescriptions: Record<string, string>;
+                description?: string | undefined;
+            }>;
+            excludedTables: string[];
+        } | undefined;
+        connectionOptions?: {
+            max: number;
+            idleTimeout: number;
+            connectionTimeout: number;
+            maxLifetime: number;
+            tls: boolean;
+            prepare: boolean;
+            bigint: boolean;
+        } | {
+            pool: {
+                max: number;
+                min: number;
+                idleTimeout: number;
+            };
+            connectionTimeout: number;
+            requestTimeout: number;
+            encrypt: boolean;
+            trustServerCertificate: boolean;
+            trustedConnection: boolean;
+            parseJSON: boolean;
+        } | undefined;
+    }[];
+    queues: (({
+        name: string;
+        autoSetup: boolean;
+        enabled: boolean;
+        publishers: Record<string, {
+            topic: string;
+            persistent: boolean;
+            routingKey?: string | undefined;
+            headers?: Record<string, string> | undefined;
+        }>;
+        subscribers: Record<string, {
+            topic: string;
+            pattern: string;
+            queue?: string | undefined;
+            group?: string | undefined;
+            durable?: boolean | undefined;
+            autoDelete?: boolean | undefined;
+            handler?: import("./queue").SubscriberHandler | undefined;
+        }>;
+        topics: Record<string, {
+            type: "headers" | "topic" | "direct" | "fanout";
+            durable: boolean;
+            autoDelete: boolean;
+        }>;
+        type: "rabbitmq";
+        connection: string | {
+            hostname: string;
+            port: number;
+            vhost: string;
+            username?: string | undefined;
+            password?: string | undefined;
+        };
+        reconnect?: {
+            initialDelay: number;
+            maxDelay: number;
+            multiplier: number;
+            maxAttempts: number;
+        } | undefined;
+    } & {
+        exchanges: Array<{
+            name: string;
+            type: "topic" | "direct" | "fanout" | "headers";
+            options?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            publishers: Array<{
+                name: string;
+                resolverName: string;
+                routingKey: string;
+                options?: {
+                    persistent?: boolean;
+                    headers?: Record<string, string>;
+                };
+            }>;
+        }>;
+        queues: Array<{
+            name: string;
+            queue?: string;
+            groupId?: string;
+            bindings: Array<{
+                exchange: string;
+                pattern: string;
+            }>;
+            queueOptions?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            handler?: import("./queue").SubscriberHandler;
+        }>;
+    }) | ({
+        name: string;
+        autoSetup: boolean;
+        enabled: boolean;
+        publishers: Record<string, {
+            topic: string;
+            persistent: boolean;
+            routingKey?: string | undefined;
+            headers?: Record<string, string> | undefined;
+        }>;
+        subscribers: Record<string, {
+            topic: string;
+            pattern: string;
+            queue?: string | undefined;
+            group?: string | undefined;
+            durable?: boolean | undefined;
+            autoDelete?: boolean | undefined;
+            handler?: import("./queue").SubscriberHandler | undefined;
+        }>;
+        topics: Record<string, {
+            type: "headers" | "topic" | "direct" | "fanout";
+            durable: boolean;
+            autoDelete: boolean;
+        }>;
+        type: "kafka";
+        connection: string | {
+            brokers: string | string[];
+            ssl: boolean;
+            clientId?: string | undefined;
+            sasl?: {
+                mechanism: "plain" | "scram-sha-256" | "scram-sha-512";
+                username: string;
+                password: string;
+            } | undefined;
+        };
+        reconnect?: {
+            initialDelay: number;
+            maxDelay: number;
+            multiplier: number;
+            maxAttempts: number;
+        } | undefined;
+    } & {
+        exchanges: Array<{
+            name: string;
+            type: "topic" | "direct" | "fanout" | "headers";
+            options?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            publishers: Array<{
+                name: string;
+                resolverName: string;
+                routingKey: string;
+                options?: {
+                    persistent?: boolean;
+                    headers?: Record<string, string>;
+                };
+            }>;
+        }>;
+        queues: Array<{
+            name: string;
+            queue?: string;
+            groupId?: string;
+            bindings: Array<{
+                exchange: string;
+                pattern: string;
+            }>;
+            queueOptions?: {
+                durable?: boolean;
+                autoDelete?: boolean;
+            };
+            handler?: import("./queue").SubscriberHandler;
+        }>;
+    }))[];
+    cron: {
+        name: string;
+        pattern: string;
+        paused: boolean;
+        catchErrors: boolean;
+        query?: string | undefined;
+        variables?: Record<string, unknown> | undefined;
+        timezone?: string | undefined;
+        maxRuns?: number | undefined;
+        interval?: number | undefined;
+        startAt?: string | undefined;
+        stopAt?: string | undefined;
+        protect?: boolean | undefined;
+        context?: Record<string, any> | undefined;
+        onTick?: import("./cron").TickCallback<Record<string, unknown>> | undefined;
+    }[];
+    operations: Record<string, {
+        graphql: {
+            enabled: boolean;
+            name?: string | undefined;
+        };
+        description?: string | undefined;
+        query?: string | undefined;
+        handler?: import("./operation").OperationHandler<any, any, any> | undefined;
+        input?: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>> | undefined;
+        output?: z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>> | undefined;
+        hooks?: {
+            init?: import("./operation").OperationInitHook<any> | undefined;
+            beforeRequest?: import("./operation").OperationBeforeRequestHook<any, any, any> | undefined;
+            afterRequest?: import("./operation").OperationAfterRequestHook<any> | undefined;
+        } | undefined;
+        rest?: {
+            path: string;
+            method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+            pathParams?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+            queryParams?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+            body?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+        } | undefined;
+        cache?: {
+            updateAgeOnHas: boolean;
+            ttlAutopurge: boolean;
+            max?: number | undefined;
+            maxSize?: number | undefined;
+            ttl?: number | undefined;
+            allowStale?: boolean | undefined;
+            updateAgeOnGet?: boolean | undefined;
+        } | undefined;
+    }>;
+    auth: {
+        permissions: {
+            [k: string]: {
+                tables: "ALL" | {
+                    [x: string]: {
+                        columns: "ALL" | string[];
+                    } & import("../configuration").TableFilter;
+                };
+                storedProcedures: string[] | "ALL";
+                queues: string[] | "ALL";
+                operations: string[] | "ALL";
+                remoteSchemas: string[] | "ALL";
+                remoteREST: string[] | "ALL";
+            };
+        };
+        enabled: boolean;
+        database: string;
+        schema: string;
+        autoCreateTables: boolean;
+    } | undefined;
+    remoteSchemas: {
+        name: string;
+        url: string;
+        enabled: boolean;
+        timeout: number;
+        prefix?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        forwardHeaders?: string[] | undefined;
+        introspection?: {
+            interval: number;
+        } | undefined;
+    }[];
+    remoteREST: {
+        name: string;
+        enabled: boolean;
+        timeout: number;
+        url?: string | undefined;
+        specUrl?: string | undefined;
+        specPath?: string | undefined;
+        prefix?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        forwardHeaders?: string[] | undefined;
+    }[];
+    ai: {
+        enabled: boolean;
+        endpoint: string;
+        mcp: {
+            enabled: boolean;
+        };
+        systemPrompt?: string | undefined;
+    };
+}>>;
+//# sourceMappingURL=configuration.d.ts.map