@graphoria/server 0.1.0

package/dist/src/singletons/cache/redisClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redisClient.d.ts","sourceRoot":"","sources":["../../../../src/singletons/cache/redisClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,IAAI,YAAY,EAAE,MAAM,KAAK,CAAC;AAMlD,eAAO,MAAM,mBAAmB,QAAO,YAAY,CAAC,OAAO,YAAY,CAKtE,CAAC"}

package/dist/src/singletons/cache/registry.d.ts

@@ -0,0 +1,7 @@
+import type { CacheStore } from "./types";
+export declare const registerCache: (name: string, cache: CacheStore) => void;
+export declare const getCache: (name: string) => CacheStore | undefined;
+export declare const InvalidationHelper: {
+    invalidate: (operationName: string, pattern?: Record<string, unknown>) => Promise<boolean>;
+};
+//# sourceMappingURL=registry.d.ts.map

package/dist/src/singletons/cache/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/singletons/cache/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAI1C,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,EAAE,OAAO,UAAU,SAE5D,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,KAAG,UAAU,GAAG,SAEpD,CAAC;AAEF,eAAO,MAAM,kBAAkB;gCAEZ,MAAM,YACX,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAChC,OAAO,CAAC,OAAO,CAAC;CAkCpB,CAAC"}

package/dist/src/singletons/cache/registry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=registry.test.d.ts.map

package/dist/src/singletons/cache/registry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.test.d.ts","sourceRoot":"","sources":["../../../../src/singletons/cache/registry.test.ts"],"names":[],"mappings":""}

package/dist/src/singletons/cache/types.d.ts

@@ -0,0 +1,8 @@
+export interface CacheStore {
+    get(key: string): Promise<unknown | undefined>;
+    set(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/singletons/cache/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/singletons/cache/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC;IAC/C,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CAC3B"}

package/dist/src/singletons/cron.d.ts

@@ -0,0 +1,69 @@
+import type { StartCronJobsReturn } from "../cron";
+import type { GqlQueryFn } from "../types/common";
+import type { CronJob } from "../types/configuration";
+export declare const instantiateCronJobs: (jobs: CronJob[], gqlQuery: GqlQueryFn<true>) => Promise<{
+    jobs: Map<string, import("../cron").ScheduledCronJob>;
+    getJob: (name: string) => import("../cron").ScheduledCronJob | undefined;
+    getAllJobs: () => import("../cron").ScheduledCronJob[];
+    pause: (name: string) => boolean;
+    resume: (name: string) => boolean;
+    trigger: (name: string) => boolean;
+    stop: (name: string) => boolean;
+    stopAll: () => void;
+    getNextRun: (name: string) => Date | null;
+    getNextRuns: (name: string, count: number) => Date[];
+    getStatus: (name: string) => {
+        exists: boolean;
+    } | {
+        isRunning: boolean;
+        isStopped: boolean;
+        isBusy: boolean;
+        nextRun: Date | null;
+        previousRun: Date | null;
+        currentRun: Date | null;
+        exists: boolean;
+    };
+    getSummary: () => {
+        name: string;
+        pattern: string;
+        executionCount: number;
+        isRunning: boolean;
+        isBusy: boolean;
+        nextRun: Date | null;
+    }[];
+    schedule: (config: CronJob) => import("../cron").ScheduledCronJob;
+}>;
+export declare const getCronJobs: () => {
+    jobs: Map<string, import("../cron").ScheduledCronJob>;
+    getJob: (name: string) => import("../cron").ScheduledCronJob | undefined;
+    getAllJobs: () => import("../cron").ScheduledCronJob[];
+    pause: (name: string) => boolean;
+    resume: (name: string) => boolean;
+    trigger: (name: string) => boolean;
+    stop: (name: string) => boolean;
+    stopAll: () => void;
+    getNextRun: (name: string) => Date | null;
+    getNextRuns: (name: string, count: number) => Date[];
+    getStatus: (name: string) => {
+        exists: boolean;
+    } | {
+        isRunning: boolean;
+        isStopped: boolean;
+        isBusy: boolean;
+        nextRun: Date | null;
+        previousRun: Date | null;
+        currentRun: Date | null;
+        exists: boolean;
+    };
+    getSummary: () => {
+        name: string;
+        pattern: string;
+        executionCount: number;
+        isRunning: boolean;
+        isBusy: boolean;
+        nextRun: Date | null;
+    }[];
+    schedule: (config: CronJob) => import("../cron").ScheduledCronJob;
+} | null;
+export declare const setCronJobs: (jobs: StartCronJobsReturn | null) => void;
+//# sourceMappingURL=cron.d.ts.map

package/dist/src/singletons/cron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron.d.ts","sourceRoot":"","sources":["../../../src/singletons/cron.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAMtD,eAAO,MAAM,mBAAmB,GAAU,MAAM,OAAO,EAAE,EAAE,UAAU,UAAU,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMpF,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAAiB,CAAC;AAE1C,eAAO,MAAM,WAAW,GAAI,MAAM,mBAAmB,GAAG,IAAI,SAE3D,CAAC"}

package/dist/src/singletons/databases.d.ts

@@ -0,0 +1,27 @@
+import { SQL } from "bun";
+import type { ConnectionPool } from "mssql";
+import type { Database } from "../types/configuration.ts";
+/**
+ * Type for database connections mapping
+ * Keys are database names from configuration, values are connection pools
+ */
+export type DatabasesConnections = Record<string, SQL | ConnectionPool>;
+/**
+ * Type for custom repository mapping
+ * Keys are database names from configuration, values are the result of repository factory
+ */
+export type RepositoryMap<TRepository = unknown> = Record<string, TRepository>;
+export declare const databasesConnections: DatabasesConnections;
+export declare const repositoryMap: RepositoryMap;
+export declare const instantiateDatabasesConnections: (databases: Database[]) => Promise<{
+    databasesConnections: DatabasesConnections;
+    repositoryMap: RepositoryMap<unknown>;
+}>;
+/**
+ * Close every open database connection and clear the singleton maps. Bun's `SQL`
+ * and mssql's `ConnectionPool` both expose `close()`. Used by
+ * `createGraphQLEngine`'s `close()` so an in-process consumer can release
+ * connections without a running server.
+ */
+export declare const disconnectDatabases: () => Promise<void>;
+//# sourceMappingURL=databases.d.ts.map

package/dist/src/singletons/databases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"databases.d.ts","sourceRoot":"","sources":["../../../src/singletons/databases.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAM1D;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,GAAG,cAAc,CAAC,CAAC;AAExE;;;GAGG;AACH,MAAM,MAAM,aAAa,CAAC,WAAW,GAAG,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;AAE/E,eAAO,MAAM,oBAAoB,EAAE,oBAAyB,CAAC;AAC7D,eAAO,MAAM,aAAa,EAAE,aAAkB,CAAC;AAE/C,eAAO,MAAM,+BAA+B,GAAU,WAAW,QAAQ,EAAE;;;EA0B1E,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,qBAS/B,CAAC"}

package/dist/src/singletons/databases.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=databases.test.d.ts.map

package/dist/src/singletons/databases.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"databases.test.d.ts","sourceRoot":"","sources":["../../../src/singletons/databases.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,494 @@
+export declare const env: {
+    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("../config").DatabaseType> | undefined;
+            onConnect?: import("../config").OnConnectHandler<import("../config").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("../config").DatabaseType> | undefined;
+                onConnect?: import("../config").OnConnectHandler<import("../config").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("../types/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("../config").DatabaseType> | undefined;
+            onConnect?: import("../config").OnConnectHandler<import("../config").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("../config").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("../config").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("../config").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("../config").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("../types/zod/cron").TickCallback<Record<string, unknown>> | undefined;
+        }[];
+        operations: Record<string, {
+            graphql: {
+                enabled: boolean;
+                name?: string | undefined;
+            };
+            description?: string | undefined;
+            query?: string | undefined;
+            handler?: import("../config").OperationHandler<any, any, any> | undefined;
+            input?: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>> | undefined;
+            output?: import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>> | undefined;
+            hooks?: {
+                init?: import("../config").OperationInitHook<any> | undefined;
+                beforeRequest?: import("../config").OperationBeforeRequestHook<any, any, any> | undefined;
+                afterRequest?: import("../config").OperationAfterRequestHook<any> | undefined;
+            } | undefined;
+            rest?: {
+                path: string;
+                method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+                pathParams?: import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> | undefined;
+                queryParams?: import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>> | undefined;
+                body?: import("zod").ZodType<unknown, unknown, import("zod/v4/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;
+    };
+};
+//# sourceMappingURL=env.d.ts.map

package/dist/src/singletons/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/singletons/env.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBACg8D,CAAC;2BAAW,CAAC;8BAAqB,CAAC;;;;;;2BAA4H,CAAC;kCAAc,CAAC;+BAAkB,CAAC;;;;;;qBAAuF,CAAC;uBAAqB,CAAC;;;;;4BAAsF,CAAC;2BAAW,CAAC;8BAAqB,CAAC;;uBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAAlc,CAAC;2BAAW,CAAC;8BAAqB,CAAC;;;;;;2BAA4H,CAAC;kCAAc,CAAC;+BAAkB,CAAC;;;;;;qBAAuF,CAAC;uBAAqB,CAAC;;;;;4BAAsF,CAAC;2BAAW,CAAC;8BAAqB,CAAC;;uBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADt2E,CAAC"}

package/dist/src/singletons/queues.d.ts

@@ -0,0 +1,17 @@
+import type { KafkaPublisher } from "../queues/kafka";
+import type { RabbitMQPublisher } from "../queues/rabbitmq";
+import type { QueueConfig } from "../types/zod/queue";
+export type QueueConnectionStatus = {
+    type: "rabbitmq" | "kafka";
+    connected: boolean;
+};
+export type QueueManager = {
+    publisherMap: () => Record<string, RabbitMQPublisher | KafkaPublisher>;
+    sendMessage: (publisherName: string, message: string | object, key?: string) => Promise<boolean> | boolean;
+    connections: () => QueueConnectionStatus[];
+    cleanup?: () => Promise<void>;
+};
+export declare let queueManager: QueueManager | undefined;
+export declare const setQueueManager: (manager: QueueManager | undefined) => void;
+export declare const instantiateQueues: (queues: QueueConfig[]) => Promise<void>;
+//# sourceMappingURL=queues.d.ts.map

package/dist/src/singletons/queues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queues.d.ts","sourceRoot":"","sources":["../../../src/singletons/queues.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAMtD,MAAM,MAAM,qBAAqB,GAAG;IAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAAC;AAEvF,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,cAAc,CAAC,CAAC;IACvE,WAAW,EAAE,CACX,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,GAAG,CAAC,EAAE,MAAM,KACT,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IAChC,WAAW,EAAE,MAAM,qBAAqB,EAAE,CAAC;IAC3C,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B,CAAC;AAEF,eAAO,IAAI,YAAY,EAAE,YAAY,GAAG,SAAS,CAAC;AAElD,eAAO,MAAM,eAAe,GAAI,SAAS,YAAY,GAAG,SAAS,SAEhE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,QAAQ,WAAW,EAAE,kBAyE5D,CAAC"}

package/dist/src/subscriptions/index.d.ts

@@ -0,0 +1,4 @@
+export type { SubscriptionContext, SubscriptionResult, SubscriptionStrategy, SubscriptionStrategyRegistry, QueryEventEmitter, DatabasePoller, } from "./types";
+export { createSubscriptionStrategyRegistry, getStrategyForSource, createDatabaseSubscriptionStrategy, createQueueSubscriptionStrategy, } from "./strategies";
+export { createDatabasePoller, type DatabasePollerConfig } from "./utils/polling";
+//# sourceMappingURL=index.d.ts.map