@graphoria/server 0.1.0

package/dist/src/types/env.d.ts

@@ -0,0 +1,2302 @@
+import { z } from "zod";
+export declare const EnvZod: z.ZodPipe<z.ZodObject<{
+    PORT: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    NODE_ENV: z.ZodDefault<z.ZodString>;
+    ADMIN_SECRET: z.ZodString;
+    CONFIGURATION: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, 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("./zod/db").DatabaseType>, import("../config").CustomRepositoryFactory<import("./zod/db").DatabaseType>>>;
+            onConnect: z.ZodOptional<z.ZodCustom<import("../config").OnConnectHandler<import("./zod/db").DatabaseType>, import("../config").OnConnectHandler<import("./zod/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("./zod/queue").SubscriberHandler, import("./zod/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("./zod/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("./zod/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("./zod/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("./zod/queue").SubscriberHandler, import("./zod/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("./zod/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("./zod/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("./zod/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("./zod/cron").TickCallback<Record<string, unknown>>, import("./zod/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("./zod/operation").OperationHandler<any, any, any>, import("./zod/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("./zod/operation").OperationInitHook<any>, import("./zod/operation").OperationInitHook<any>>>;
+                beforeRequest: z.ZodOptional<z.ZodCustom<import("./zod/operation").OperationBeforeRequestHook<any, any, any>, import("./zod/operation").OperationBeforeRequestHook<any, any, any>>>;
+                afterRequest: z.ZodOptional<z.ZodCustom<import("./zod/operation").OperationAfterRequestHook<any>, import("./zod/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("./zod/db").DatabaseType> | undefined;
+            onConnect?: import("../config").OnConnectHandler<import("./zod/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("./zod/db").DatabaseType> | undefined;
+                onConnect?: import("../config").OnConnectHandler<import("./zod/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("./zod/db").DatabaseType> | undefined;
+            onConnect?: import("../config").OnConnectHandler<import("./zod/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("./zod/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("./zod/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("./zod/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("./zod/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("./zod/cron").TickCallback<Record<string, unknown>> | undefined;
+        }[];
+        operations: Record<string, {
+            graphql: {
+                enabled: boolean;
+                name?: string | undefined;
+            };
+            description?: string | undefined;
+            query?: string | undefined;
+            handler?: import("./zod/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("./zod/operation").OperationInitHook<any> | undefined;
+                beforeRequest?: import("./zod/operation").OperationBeforeRequestHook<any, any, any> | undefined;
+                afterRequest?: import("./zod/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("./zod/db").DatabaseType> | undefined;
+            onConnect?: import("../config").OnConnectHandler<import("./zod/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("./zod/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("./zod/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("./zod/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("./zod/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("./zod/cron").TickCallback<Record<string, unknown>> | undefined;
+        }[];
+        operations: Record<string, {
+            graphql: {
+                enabled: boolean;
+                name?: string | undefined;
+            };
+            description?: string | undefined;
+            query?: string | undefined;
+            handler?: import("./zod/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("./zod/operation").OperationInitHook<any> | undefined;
+                beforeRequest?: import("./zod/operation").OperationBeforeRequestHook<any, any, any> | undefined;
+                afterRequest?: import("./zod/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;
+        };
+    }>>]>>;
+    ANONYMOUS_ROLE: z.ZodDefault<z.ZodString>;
+    JWT_SECRET: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    JWT_EXPIRES_IN: z.ZodDefault<z.ZodString>;
+    JWT_RT_EXPIRES_IN: z.ZodDefault<z.ZodString>;
+    PASETO_LOCAL_KEY: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    PASETO_SECRET_KEY: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    PASETO_PUBLIC_KEY: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    AUTH_STRATEGY: z.ZodOptional<z.ZodEnum<{
+        jwt: "jwt";
+        paseto_local: "paseto_local";
+        paseto_public: "paseto_public";
+    }>>;
+    REDIS_URL: z.ZodDefault<z.ZodString>;
+    CACHE_STORE: z.ZodDefault<z.ZodEnum<{
+        memory: "memory";
+        redis: "redis";
+    }>>;
+    REST_API_PREFIX: z.ZodDefault<z.ZodString>;
+    GRAPHQL_API_ENDPOINT: z.ZodDefault<z.ZodString>;
+    ADMIN_SECRET_HEADER: z.ZodDefault<z.ZodString>;
+    AUTHORIZATION_HEADER: z.ZodDefault<z.ZodString>;
+    GRAPHIQL_ENDPOINT: z.ZodDefault<z.ZodString>;
+    SCALAR_ENDPOINT: z.ZodDefault<z.ZodString>;
+    OPENAPI_ENDPOINT: z.ZodDefault<z.ZodString>;
+    SUPERADMIN_ROLE: z.ZodDefault<z.ZodString>;
+    CONSOLE_ENABLED: z.ZodDefault<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
+    CONSOLE_ENDPOINT: z.ZodDefault<z.ZodString>;
+    PREFIX: z.ZodDefault<z.ZodString>;
+    CORS_ENABLED: z.ZodDefault<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
+    PRINT_SCHEMAS: z.ZodDefault<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
+    SCHEMAS_OUTPUT_DIR: z.ZodDefault<z.ZodString>;
+    QUERY_ON_RESPONSE: z.ZodDefault<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
+    MAX_QUERY_DEPTH: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    AI_ENABLED: z.ZodOptional<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
+    AI_GRAPHQL_ENABLED: z.ZodDefault<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
+    AI_REST_ENABLED: z.ZodDefault<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
+    AI_MCP_ENABLED: z.ZodOptional<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
+    AI_MCP_ENDPOINT: z.ZodDefault<z.ZodString>;
+    AI_MCP_REQUIRE_ADMIN_SECRET: z.ZodDefault<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
+    AI_MCP_MAX_QUERY_DEPTH: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    AI_MCP_DISABLED_TOOLS: z.ZodDefault<z.ZodString>;
+    AI_MCP_DISABLED_RESOURCES: z.ZodDefault<z.ZodString>;
+    AI_MCP_DISABLED_PROMPTS: z.ZodDefault<z.ZodString>;
+    AI_SYSTEM_PROMPT: z.ZodOptional<z.ZodString>;
+    AI_PROMPT_TEMPLATE: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodTransform<{
+    port: number;
+    nodeEnv: string;
+    version: string;
+    configuration: string | {
+        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("./zod/db").DatabaseType> | undefined;
+            onConnect?: import("../config").OnConnectHandler<import("./zod/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("./zod/db").DatabaseType> | undefined;
+                onConnect?: import("../config").OnConnectHandler<import("./zod/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("./zod/db").DatabaseType> | undefined;
+            onConnect?: import("../config").OnConnectHandler<import("./zod/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("./zod/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("./zod/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("./zod/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("./zod/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("./zod/cron").TickCallback<Record<string, unknown>> | undefined;
+        }[];
+        operations: Record<string, {
+            graphql: {
+                enabled: boolean;
+                name?: string | undefined;
+            };
+            description?: string | undefined;
+            query?: string | undefined;
+            handler?: import("./zod/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("./zod/operation").OperationInitHook<any> | undefined;
+                beforeRequest?: import("./zod/operation").OperationBeforeRequestHook<any, any, any> | undefined;
+                afterRequest?: import("./zod/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;
+        };
+    } | undefined;
+    prefix: string;
+    enableCors: boolean;
+    restApiPrefix: string;
+    graphqlApiEndpoint: string;
+    graphiqlEndpoint: string;
+    scalarEndpoint: string;
+    openApiEndpoint: string;
+    authorizationHeader: string;
+    anonymousRole: string;
+    authStrategy: "jwt" | "paseto_local" | "paseto_public" | undefined;
+    queryOnResponse: boolean;
+    maxQueryDepth: number;
+    admin: {
+        secret: string;
+        header: string;
+    };
+    jwt: {
+        secret: string;
+        expiresIn: string;
+        rtExpiresIn: string;
+    };
+    paseto: {
+        localKey: string;
+        secretKey: string;
+        publicKey: string;
+    };
+    cache: {
+        store: "memory" | "redis";
+        redisUrl: string;
+    };
+    schemas: {
+        print: boolean;
+        outputDir: string;
+    };
+    superadmin: {
+        role: string;
+    };
+    console: {
+        enabled: boolean;
+        endpoint: string;
+    };
+    ai: {
+        enabled: boolean | undefined;
+        graphqlEnabled: boolean;
+        restEnabled: boolean;
+        mcp: {
+            enabled: boolean | undefined;
+            endpoint: string;
+            requireAdminSecret: boolean;
+            maxQueryDepth: number | undefined;
+            disabledTools: string[];
+            disabledResources: string[];
+            disabledPrompts: string[];
+        };
+        systemPrompt: string | undefined;
+        promptTemplate: string | undefined;
+    };
+}, {
+    PORT: number;
+    NODE_ENV: string;
+    ADMIN_SECRET: string;
+    ANONYMOUS_ROLE: string;
+    JWT_SECRET: string;
+    JWT_EXPIRES_IN: string;
+    JWT_RT_EXPIRES_IN: string;
+    PASETO_LOCAL_KEY: string;
+    PASETO_SECRET_KEY: string;
+    PASETO_PUBLIC_KEY: string;
+    REDIS_URL: string;
+    CACHE_STORE: "memory" | "redis";
+    REST_API_PREFIX: string;
+    GRAPHQL_API_ENDPOINT: string;
+    ADMIN_SECRET_HEADER: string;
+    AUTHORIZATION_HEADER: string;
+    GRAPHIQL_ENDPOINT: string;
+    SCALAR_ENDPOINT: string;
+    OPENAPI_ENDPOINT: string;
+    SUPERADMIN_ROLE: string;
+    CONSOLE_ENABLED: boolean;
+    CONSOLE_ENDPOINT: string;
+    PREFIX: string;
+    CORS_ENABLED: boolean;
+    PRINT_SCHEMAS: boolean;
+    SCHEMAS_OUTPUT_DIR: string;
+    QUERY_ON_RESPONSE: boolean;
+    MAX_QUERY_DEPTH: number;
+    AI_GRAPHQL_ENABLED: boolean;
+    AI_REST_ENABLED: boolean;
+    AI_MCP_ENDPOINT: string;
+    AI_MCP_REQUIRE_ADMIN_SECRET: boolean;
+    AI_MCP_DISABLED_TOOLS: string;
+    AI_MCP_DISABLED_RESOURCES: string;
+    AI_MCP_DISABLED_PROMPTS: string;
+    CONFIGURATION?: string | {
+        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("./zod/db").DatabaseType> | undefined;
+            onConnect?: import("../config").OnConnectHandler<import("./zod/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("./zod/db").DatabaseType> | undefined;
+                onConnect?: import("../config").OnConnectHandler<import("./zod/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("./zod/db").DatabaseType> | undefined;
+            onConnect?: import("../config").OnConnectHandler<import("./zod/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("./zod/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("./zod/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("./zod/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("./zod/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("./zod/cron").TickCallback<Record<string, unknown>> | undefined;
+        }[];
+        operations: Record<string, {
+            graphql: {
+                enabled: boolean;
+                name?: string | undefined;
+            };
+            description?: string | undefined;
+            query?: string | undefined;
+            handler?: import("./zod/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("./zod/operation").OperationInitHook<any> | undefined;
+                beforeRequest?: import("./zod/operation").OperationBeforeRequestHook<any, any, any> | undefined;
+                afterRequest?: import("./zod/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;
+        };
+    } | undefined;
+    AUTH_STRATEGY?: "jwt" | "paseto_local" | "paseto_public" | undefined;
+    AI_ENABLED?: boolean | undefined;
+    AI_MCP_ENABLED?: boolean | undefined;
+    AI_MCP_MAX_QUERY_DEPTH?: number | undefined;
+    AI_SYSTEM_PROMPT?: string | undefined;
+    AI_PROMPT_TEMPLATE?: string | undefined;
+}>>;
+export type EnvInput = z.input<typeof EnvZod>;
+export type Env = z.infer<typeof EnvZod> & {
+    logger?: import("pino").Logger | import("pino").LoggerOptions;
+};
+declare module "bun" {
+    interface Env extends EnvInput {
+        VERSION?: string;
+    }
+}
+//# sourceMappingURL=env.d.ts.map