@bikdotai/bik-shared-backend 20.4.1-beta.0 → 20.4.1

package/lib/auth/secret-manager/configManager.firestore.js

@@ -1,166 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FirestoreConfigManager = void 0;
-const config_1 = require("../config");
-class FirestoreConfigManager {
-    constructor() {
-        this.secretsCollection = 'secrets';
-        this.envDocPrefix = 'bik-platform-secrets-';
-        this.globalSecretsDocId = 'bik-platform-secrets-globalsecrets';
-        const app = (0, config_1.getSecondaryApp)();
-        this.db = app.firestore();
-    }
-    static getInstance() {
-        if (!FirestoreConfigManager.instance) {
-            FirestoreConfigManager.instance = new FirestoreConfigManager();
-        }
-        return FirestoreConfigManager.instance;
-    }
-    getDocId(section, podName) {
-        if (section === 'secrets') {
-            return this.globalSecretsDocId;
-        }
-        return `${this.envDocPrefix}${podName}`;
-    }
-    isDocFromSection(section, docId) {
-        if (section === 'secrets') {
-            return docId === this.globalSecretsDocId;
-        }
-        return docId.startsWith(this.envDocPrefix) && docId !== this.globalSecretsDocId;
-    }
-    getPodNameFromDocId(section, docId) {
-        if (!this.isDocFromSection(section, docId)) {
-            return undefined;
-        }
-        if (section === 'secrets') {
-            return 'global';
-        }
-        const podName = docId.replace(this.envDocPrefix, '');
-        if (!podName) {
-            return undefined;
-        }
-        return podName;
-    }
-    toEmptySchema(schema) {
-        if (!schema || typeof schema !== 'object') {
-            return { generic: {} };
-        }
-        const normalized = { generic: {} };
-        Object.keys(schema).forEach((serviceName) => {
-            const category = schema[serviceName];
-            normalized[serviceName] = category && typeof category === 'object' ? Object.assign({}, category) : {};
-        });
-        if (!normalized.generic) {
-            normalized.generic = {};
-        }
-        return normalized;
-    }
-    getConfig(section, podName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const id = this.getDocId(section, podName);
-                const docRef = this.db.collection(this.secretsCollection).doc(id);
-                const docSnap = yield docRef.get();
-                const docData = docSnap.data();
-                return {
-                    id,
-                    section,
-                    podName,
-                    schema: this.toEmptySchema(docData === null || docData === void 0 ? void 0 : docData.schema),
-                    updatedAtMills: (docData === null || docData === void 0 ? void 0 : docData.updatedAtMills) || Date.now(),
-                    updatedBy: (docData === null || docData === void 0 ? void 0 : docData.updatedBy) || 'NA',
-                };
-            }
-            catch (error) {
-                throw new Error(`Failed to retrieve config: ${error}`);
-            }
-        });
-    }
-    storeConfig(section, podName, schema, updatedBy = 'NA') {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const id = this.getDocId(section, podName);
-                const configDoc = {
-                    id,
-                    section,
-                    podName,
-                    schema: this.toEmptySchema(schema),
-                    updatedAtMills: Date.now(),
-                    updatedBy,
-                };
-                const docRef = this.db.collection(this.secretsCollection).doc(id);
-                yield docRef.set(configDoc);
-            }
-            catch (error) {
-                throw new Error(`Failed to store config: ${error}`);
-            }
-        });
-    }
-    getAll(section) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const snapshot = yield this.db.collection(this.secretsCollection).get();
-                const configs = {};
-                snapshot.forEach((doc) => {
-                    if (!this.isDocFromSection(section, doc.id)) {
-                        return;
-                    }
-                    const docData = doc.data();
-                    const podName = docData.podName || this.getPodNameFromDocId(section, doc.id);
-                    if (!podName) {
-                        return;
-                    }
-                    if (section === 'secrets' && podName !== 'global') {
-                        return;
-                    }
-                    configs[podName] = this.toEmptySchema(docData.schema);
-                });
-                return configs;
-            }
-            catch (error) {
-                throw new Error(`Failed to retrieve all configs for section ${section}: ${error}`);
-            }
-        });
-    }
-    getAllConfigs() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const snapshot = yield this.db.collection(this.secretsCollection).get();
-                const envVariables = {};
-                const secrets = {};
-                snapshot.forEach((doc) => {
-                    if (doc.id.startsWith(this.envDocPrefix) && doc.id !== this.globalSecretsDocId) {
-                        const docData = doc.data();
-                        const podName = docData.podName || this.getPodNameFromDocId('envVariables', doc.id);
-                        if (!podName) {
-                            return;
-                        }
-                        envVariables[podName] = this.toEmptySchema(docData.schema);
-                        return;
-                    }
-                    if (doc.id === this.globalSecretsDocId) {
-                        const docData = doc.data();
-                        secrets.global = this.toEmptySchema(docData.schema);
-                    }
-                });
-                return {
-                    envVariables,
-                    secrets,
-                };
-            }
-            catch (error) {
-                throw new Error(`Failed to retrieve all configs: ${error}`);
-            }
-        });
-    }
-}
-exports.FirestoreConfigManager = FirestoreConfigManager;

package/lib/auth/secret-manager/configManager.helper.d.ts

@@ -1,13 +0,0 @@
-import { ResolvedFunctionResponse } from '../../apis';
-import { ConfigManagerService } from './configManager.service';
-import { CheckConflictsResponse, GetConfigRequest, PodConfigData, StoreConfigRequest, UnifiedConfigsData } from './configManager.model';
-export declare class ConfigManagerHelper {
-    private service;
-    constructor(service?: ConfigManagerService);
-    getAllConfigs(): ResolvedFunctionResponse<UnifiedConfigsData>;
-    getConfig(request: GetConfigRequest): ResolvedFunctionResponse<PodConfigData>;
-    storeConfig(request: StoreConfigRequest): ResolvedFunctionResponse<{
-        success: boolean;
-    }>;
-    checkConflicts(request: StoreConfigRequest): ResolvedFunctionResponse<CheckConflictsResponse>;
-}

package/lib/auth/secret-manager/configManager.helper.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigManagerHelper = void 0;
-const apis_1 = require("../../apis");
-const configManager_service_1 = require("./configManager.service");
-class ConfigManagerHelper {
-    constructor(service = new configManager_service_1.ConfigManagerService()) {
-        this.service = service;
-    }
-    getAllConfigs() {
-        return this.service.getAllConfigs();
-    }
-    getConfig(request) {
-        if (!(request === null || request === void 0 ? void 0 : request.podName)) {
-            return Promise.resolve(apis_1.FunctionResponseHelper.failed(apis_1.ErrorCodes.VALIDATION_FAILED, 'podName is required', 'podName is required'));
-        }
-        return this.service.getConfig(request);
-    }
-    storeConfig(request) {
-        if (!(request === null || request === void 0 ? void 0 : request.section) || !(request === null || request === void 0 ? void 0 : request.podName) || !(request === null || request === void 0 ? void 0 : request.schema)) {
-            return Promise.resolve(apis_1.FunctionResponseHelper.failed(apis_1.ErrorCodes.VALIDATION_FAILED, 'section, podName and schema are required', 'section, podName and schema are required'));
-        }
-        return this.service.storeConfig(request);
-    }
-    checkConflicts(request) {
-        if (!(request === null || request === void 0 ? void 0 : request.section) || !(request === null || request === void 0 ? void 0 : request.podName) || !(request === null || request === void 0 ? void 0 : request.schema)) {
-            return Promise.resolve(apis_1.FunctionResponseHelper.failed(apis_1.ErrorCodes.VALIDATION_FAILED, 'section, podName and schema are required', 'section, podName and schema are required'));
-        }
-        return this.service.checkConflicts(request);
-    }
-}
-exports.ConfigManagerHelper = ConfigManagerHelper;

package/lib/auth/secret-manager/configManager.model.d.ts

@@ -1,38 +0,0 @@
-import { PodNameOrGlobal, SecretSchema } from './secretManager.model';
-export type ConfigSection = 'envVariables' | 'secrets';
-export interface StoreConfigRequest {
-    section: ConfigSection;
-    podName: PodNameOrGlobal;
-    schema: SecretSchema;
-}
-export interface GetConfigRequest {
-    podName: PodNameOrGlobal;
-}
-export interface UnifiedConfigsData {
-    envVariables: Record<string, SecretSchema>;
-    secrets: Record<string, SecretSchema>;
-}
-export interface PodConfigData {
-    podName: PodNameOrGlobal;
-    envVariables: SecretSchema;
-    secrets: Record<'global', SecretSchema>;
-}
-export interface ConflictItem {
-    serviceName: string;
-    keyName: string;
-    existingPods: string[];
-    currentValue: string;
-    existingValues: Record<string, string>;
-}
-export interface CheckConflictsResponse {
-    hasConflicts: boolean;
-    conflicts: ConflictItem[];
-}
-export interface ConfigDocument {
-    id: string;
-    section: ConfigSection;
-    podName: PodNameOrGlobal;
-    schema: SecretSchema;
-    updatedAtMills: number;
-    updatedBy: string;
-}

package/lib/auth/secret-manager/configManager.model.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/auth/secret-manager/configManager.service.d.ts

@@ -1,17 +0,0 @@
-import { ResolvedFunctionResponse } from '../../apis';
-import { FirestoreConfigManager } from './configManager.firestore';
-import { CheckConflictsResponse, GetConfigRequest, StoreConfigRequest, UnifiedConfigsData, PodConfigData } from './configManager.model';
-export declare class ConfigManagerService {
-    private configStore;
-    constructor(configStore?: FirestoreConfigManager);
-    private normalizeSchema;
-    private validateSectionAndPod;
-    getAllConfigs(): ResolvedFunctionResponse<UnifiedConfigsData>;
-    getConfig({ podName }: GetConfigRequest): ResolvedFunctionResponse<PodConfigData>;
-    storeConfig(request: StoreConfigRequest): ResolvedFunctionResponse<{
-        success: boolean;
-    }>;
-    private getExistingPodsAndValues;
-    checkConflicts(request: StoreConfigRequest): ResolvedFunctionResponse<CheckConflictsResponse>;
-    static getInvalidSecretsPodMessage(): string;
-}

package/lib/auth/secret-manager/configManager.service.js

@@ -1,138 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigManagerService = void 0;
-const apis_1 = require("../../apis");
-const configManager_firestore_1 = require("./configManager.firestore");
-const INVALID_SECRETS_POD_ERROR = 'Secrets are supported only for podName=global';
-class ConfigManagerService {
-    constructor(configStore = configManager_firestore_1.FirestoreConfigManager.getInstance()) {
-        this.configStore = configStore;
-    }
-    normalizeSchema(schema) {
-        if (!schema || typeof schema !== 'object') {
-            return { generic: {} };
-        }
-        const normalized = { generic: {} };
-        Object.keys(schema).forEach((serviceName) => {
-            const category = schema[serviceName];
-            normalized[serviceName] = category && typeof category === 'object' ? Object.assign({}, category) : {};
-        });
-        if (!normalized.generic) {
-            normalized.generic = {};
-        }
-        return normalized;
-    }
-    validateSectionAndPod(section, podName) {
-        if (section === 'secrets' && podName !== 'global') {
-            return INVALID_SECRETS_POD_ERROR;
-        }
-        return null;
-    }
-    getAllConfigs() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const allConfigs = yield this.configStore.getAllConfigs();
-            const envVariables = {};
-            Object.keys(allConfigs.envVariables || {}).forEach((podName) => {
-                envVariables[podName] = this.normalizeSchema(allConfigs.envVariables[podName]);
-            });
-            const secrets = {};
-            if ((_a = allConfigs.secrets) === null || _a === void 0 ? void 0 : _a.global) {
-                secrets.global = this.normalizeSchema(allConfigs.secrets.global);
-            }
-            return apis_1.FunctionResponseHelper.success({
-                envVariables,
-                secrets,
-            });
-        });
-    }
-    getConfig({ podName }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [envConfig, globalSecretConfig] = yield Promise.all([
-                this.configStore.getConfig('envVariables', podName),
-                this.configStore.getConfig('secrets', 'global'),
-            ]);
-            return apis_1.FunctionResponseHelper.success({
-                podName,
-                envVariables: this.normalizeSchema(envConfig.schema),
-                secrets: {
-                    global: this.normalizeSchema(globalSecretConfig.schema),
-                },
-            });
-        });
-    }
-    storeConfig(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const validationError = this.validateSectionAndPod(request.section, request.podName);
-            if (validationError) {
-                return apis_1.FunctionResponseHelper.failed(apis_1.ErrorCodes.VALIDATION_FAILED, validationError, validationError);
-            }
-            yield this.configStore.storeConfig(request.section, request.podName, this.normalizeSchema(request.schema));
-            return apis_1.FunctionResponseHelper.success({ success: true });
-        });
-    }
-    getExistingPodsAndValues(section, podName, allConfigs, serviceName, keyName) {
-        const existingValues = {};
-        Object.keys(allConfigs).forEach((existingPodName) => {
-            var _a, _b;
-            if (section === 'envVariables' && existingPodName === podName) {
-                return;
-            }
-            const existingValue = (_b = (_a = allConfigs[existingPodName]) === null || _a === void 0 ? void 0 : _a[serviceName]) === null || _b === void 0 ? void 0 : _b[keyName];
-            if (typeof existingValue === 'string') {
-                existingValues[existingPodName] = existingValue;
-            }
-        });
-        return existingValues;
-    }
-    checkConflicts(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const validationError = this.validateSectionAndPod(request.section, request.podName);
-            if (validationError) {
-                return apis_1.FunctionResponseHelper.failed(apis_1.ErrorCodes.VALIDATION_FAILED, validationError, validationError);
-            }
-            const normalizedSchema = this.normalizeSchema(request.schema);
-            const allConfigs = yield this.configStore.getAll(request.section);
-            const conflicts = [];
-            Object.keys(normalizedSchema).forEach((serviceName) => {
-                const keys = normalizedSchema[serviceName] || {};
-                Object.keys(keys).forEach((keyName) => {
-                    const currentValue = keys[keyName] || '';
-                    const existingValues = this.getExistingPodsAndValues(request.section, request.podName, allConfigs, serviceName, keyName);
-                    const existingPods = Object.keys(existingValues);
-                    if (existingPods.length === 0) {
-                        return;
-                    }
-                    const hasDifferentValue = existingPods.some((pod) => existingValues[pod] !== currentValue);
-                    if (!hasDifferentValue) {
-                        return;
-                    }
-                    conflicts.push({
-                        serviceName,
-                        keyName,
-                        existingPods,
-                        currentValue,
-                        existingValues,
-                    });
-                });
-            });
-            return apis_1.FunctionResponseHelper.success({
-                hasConflicts: conflicts.length > 0,
-                conflicts,
-            });
-        });
-    }
-    static getInvalidSecretsPodMessage() {
-        return INVALID_SECRETS_POD_ERROR;
-    }
-}
-exports.ConfigManagerService = ConfigManagerService;

package/lib/core/local_runner.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/core/local_runner.js

@@ -1,60 +0,0 @@
-"use strict";
-// Boilerplate code to easily run bik-shared-backend locally
-// To run this in local please do npx tsc && npx ts-node src/core/local_runner.ts
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const setup_1 = __importDefault(require("../logger/setup"));
-const setup_2 = require("./setup");
-const alertsV2_service_1 = require("../alertsV2/alertsV2.service");
-const constants_1 = require("@bikdotai/bik-models/core/constants");
-setup_2.BikBackendSetup.setUpV2({
-    slackConfiguration: {
-        slackChannelId: 'C04LEGSM0Q2',
-    },
-    useSharedFirebase: true,
-}).then(() => {
-    setup_1.default.setUp([console, console]);
-    console.log('BikBackendSetup done');
-    // Uncomment to run the simulation when you start this file.
-    for (let i = 0; i < 1; i++) {
-        simulateSendAlert().then().catch(console.error);
-    }
-});
-/**
- * Function to simulate concurrent Redis requests
- */
-// async function test() {}
-// test().then().catch();
-/**
- * Minimal local simulation for Alerts V2 `sendAlert`.
- *
- * Notes:
- * - This hits repo lookups + channel senders.
- * - If `alertConfigId` doesn't exist (or is inactive), you'd see `RESOURCE_NOT_FOUND` or a success no-op.
- * - Keep `types` undefined to use whatever channels are configured on the alert config.
- */
-function simulateSendAlert() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const alertsV2Service = new alertsV2_service_1.AlertsV2Service();
-        // TODO: Replace these with real IDs from your env.
-        const res = yield alertsV2Service.sendAlert({
-            alertConfigId: 'PE294r6xtYgMzCVMgiEK',
-            storeId: 'p60HYv5wjgQaOrPdqT5NjbpkroD2',
-            sentBy: constants_1.POD_NAME.CAMPAIGN,
-            agentId: ['amankun77@gmail.com'],
-            variables: ['Hi', 'Sir', 'Aman', 'You have been conned', "https://google.co.in", "go to google.com"],
-        });
-        console.log('sendAlert response:', JSON.stringify(res, null, 2));
-    });
-}

package/lib/database/database.model.d.ts

@@ -1,95 +0,0 @@
-/**
- * Types and Interfaces for Database Service
- */
-import { Sequelize } from 'sequelize';
-import { Pool } from 'pg';
-/**
- * PostgreSQL configuration interface
- */
-export interface PgConfig {
-    username: string;
-    password: string;
-    host: string;
-    read?: Array<{
-        host: string;
-    }>;
-    database: string;
-    dialect: string;
-    schema: string;
-    port: number;
-}
-/**
- * Options for creating a Sequelize connection
- */
-export interface SequelizeConnectionOptions {
-    /** Maximum number of connections in the pool (default: 15) */
-    maxConnections?: number;
-    /** Minimum number of connections in the pool (default: 1) */
-    minConnections?: number;
-    /** Maximum time in milliseconds to acquire a connection (default: 60000) */
-    acquireTimeout?: number;
-    /** Maximum time in milliseconds for a connection to be idle before being released (default: 1000) */
-    idleTimeout?: number;
-    /** Maximum number of retry attempts for failed connections (default: 20) */
-    maxRetries?: number;
-    /** Initial backoff duration in milliseconds for retries (default: 500) */
-    backoffBase?: number;
-    /** Exponent to increase backoff duration on each retry (default: 1.2) */
-    backoffExponent?: number;
-    /** Enable SQL query logging (default: false) */
-    enableLogging?: boolean;
-    /** Override database schema from secret */
-    customSchema?: string;
-    /**
-     * Enable API metadata in SQL queries for tracking (default: true)
-     *
-     * When enabled, automatically sets PostgreSQL application_name to 'bik:{apiName}'
-     * for every query, making it visible in:
-     * - Aurora Performance Insights (group by application_name dimension)
-     * - pg_stat_activity (real-time query monitoring)
-     * - CloudWatch Logs (historical analysis)
-     *
-     * API name is extracted from LogExecutionContextHelper.getContext()?.apiName
-     * Format: 'bik:{apiName}' for write pools, 'bik:{apiName}:read' for reader pools
-     */
-    enableQueryMetadata?: boolean;
-}
-/**
- * Options for creating a PostgreSQL Pool connection
- */
-export interface PoolConnectionOptions {
-    /** Maximum number of connections in the pool (default: 15) */
-    maxConnections?: number;
-    /** Minimum number of connections in the pool (default: 0) */
-    minConnections?: number;
-    /** Connection idle timeout in milliseconds (default: 1000) */
-    idleTimeout?: number;
-}
-/**
- * Result of creating all database connections
- */
-export interface DatabaseConnections {
-    /** Sequelize ORM instance for complex queries and models */
-    sequelize: Sequelize;
-    /** PostgreSQL Pool for write operations */
-    pool: Pool;
-    /** PostgreSQL Pool for read operations (uses read replicas) */
-    readerPool: Pool;
-}
-/**
- * Connections object for cleanup
- */
-export interface ConnectionsToClose {
-    sequelize?: Sequelize;
-    pool?: Pool;
-    readerPool?: Pool;
-}
-/**
- * Options passed to Sequelize beforeQuery hook
- */
-export interface BeforeQueryOptions {
-    sql?: string;
-    bind?: any;
-    type?: string;
-    [key: string]: any;
-}

package/lib/database/database.model.js

@@ -1,5 +0,0 @@
-"use strict";
-/**
- * Types and Interfaces for Database Service
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/database/database.service.d.ts

@@ -1,90 +0,0 @@
-/**
- * Database Service
- *
- * Provides generic database connection management for PostgreSQL using Sequelize and node-postgres.
- * Supports connection pooling, read replicas, auto-retry logic, and Secret Manager integration.
- */
-import { Sequelize } from 'sequelize';
-import { Pool } from 'pg';
-import { SequelizeConnectionOptions, PoolConnectionOptions, DatabaseConnections, ConnectionsToClose } from './database.model';
-export declare const databaseSchema: string;
-export declare const ENABLE_SEQUELIZE_LOGGING: boolean;
-/**
- * Service class for managing database connections
- * Provides generic functions to create Sequelize and pg Pool connections
- */
-export declare class DatabaseService {
-    private static pgConfigCache;
-    /**
-     * Get PostgreSQL configuration from secrets
-     * @param secretKeyName - Optional custom secret key name (defaults to 'aurora-common')
-     * @returns Promise<PgConfig>
-     */
-    private static getPgConfig;
-    /**
-     * Reset the cached config (useful for testing or when secrets change)
-     */
-    static resetConfigCache(): void;
-    /**
-     * Create a Sequelize instance with optimal configuration
-     * @param options - Optional configuration for connection pooling and retry logic
-     * @param secretKeyName - Optional custom secret key name
-     * @returns Promise<Sequelize>
-     */
-    static createSequelizeConnection(options?: SequelizeConnectionOptions, secretKeyName?: string): Promise<Sequelize>;
-    /**
-     * Create a PostgreSQL Pool for raw queries (write operations)
-     * @param options - Optional configuration for connection pooling
-     * @param secretKeyName - Optional custom secret key name
-     * @returns Promise<Pool>
-     */
-    static createPool(options?: PoolConnectionOptions, secretKeyName?: string): Promise<Pool>;
-    /**
-     * Create a PostgreSQL Pool for read operations (using read replicas)
-     * @param options - Optional configuration for connection pooling
-     * @param secretKeyName - Optional custom secret key name
-     * @returns Promise<Pool>
-     */
-    static createReaderPool(options?: PoolConnectionOptions, secretKeyName?: string): Promise<Pool>;
-    /**
-     * Create all database connections at once
-     * Useful for initializing all required connections at application startup
-     * @param options - Optional configuration for connection pooling
-     * @param secretKeyName - Optional custom secret key name
-     * @returns Promise with all connection types
-     */
-    static createAllConnections(options?: SequelizeConnectionOptions & PoolConnectionOptions, secretKeyName?: string): Promise<DatabaseConnections>;
-    /**
-     * Test database connection
-     * @param sequelize - Sequelize instance to test
-     * @returns Promise<boolean>
-     */
-    static testConnection(sequelize: Sequelize): Promise<boolean>;
-    /**
-     * Gracefully close all connections
-     * @param connections - Object containing all connection instances
-     */
-    static closeConnections(connections: ConnectionsToClose): Promise<void>;
-}
-/**
- * Get or create the default Sequelize instance (Singleton)
- * @returns Promise<Sequelize>
- */
-export declare const getDefaultSequelize: () => Promise<Sequelize>;
-/**
- * Get or create the default Pool instance (Singleton)
- * @returns Promise<Pool>
- */
-export declare const getDefaultPool: () => Promise<Pool>;
-/**
- * Get or create the default Reader Pool instance (Singleton)
- * @returns Promise<Pool>
- */
-export declare const getDefaultReaderPool: () => Promise<Pool>;
-/**
- * Reset all singleton instances (useful for testing)
- */
-export declare const resetDefaultConnections: () => void;
-export declare const BikSequelize: Promise<Sequelize>;
-export declare const pool: Promise<Pool>;
-export declare const readerPool: Promise<Pool>;