core-services-sdk 1.3.22 → 1.3.24

package/types/core/normalize-premitives-types-or-default.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Normalize Utilities
+ *
+ * Small helpers to guarantee stable, predictable values from user/config inputs.
+ * When an incoming value is missing, malformed, or in a different-but-supported
+ * representation (e.g., number/boolean as string), these utilities either accept
+ * it (after safe normalization) or return a default you control.
+ *
+ * Design highlights:
+ * - Keep call sites compact and intention-revealing.
+ * - Be strict for strings (no implicit type coercion).
+ * - Be permissive for number/boolean when the input is a string in an accepted form.
+ * - Fast, side-effect free, no deep cloning — values are returned by reference when valid.
+ */
+/**
+ * Generic predicate-based normalization.
+ *
+ * Purpose:
+ *  Ensure a value conforms to a caller-provided predicate; otherwise return a provided default.
+ *  Useful when you need a single reusable pattern for custom shapes or policies
+ *  (e.g., "must be a non-empty array of strings", "must be a plain object", etc.).
+ *
+ * Behavior:
+ *  - Calls `isValid(value)`.
+ *  - If the predicate returns true → returns `value` (as-is).
+ *  - Otherwise → returns `defaultValue` (as-is).
+ *
+ * Performance & Safety:
+ *  - O(1) aside from your predicate cost.
+ *  - No cloning or sanitization is performed.
+ *  - Ensure `isValid` is pure and fast; avoid throwing inside it.
+ *
+ * @template T
+ * @param {any} value
+ *   Candidate input to validate.
+ * @param {(v:any)=>boolean} isValid
+ *   Validation predicate. Return true iff the input is acceptable.
+ * @param {T} defaultValue
+ *   Fallback to return when `value` fails validation.
+ * @returns {T}
+ *   The original `value` when valid; otherwise `defaultValue`.
+ *
+ * @example
+ * // Ensure a finite number
+ * normalizeOrDefault(5, v => typeof v === 'number' && Number.isFinite(v), 0) // → 5
+ * normalizeOrDefault('x', v => typeof v === 'number', 0)                     // → 0
+ *
+ * @example
+ * // Ensure an object (non-null, non-array)
+ * const cfg = normalizeOrDefault(
+ *   maybeCfg,
+ *   v => v && typeof v === 'object' && !Array.isArray(v),
+ *   {}
+ * )
+ */
+export function normalizeOrDefault<T>(value: any, isValid: (v: any) => boolean, defaultValue: T): T;
+/**
+ * Normalize a value to a non-empty, trimmed string; otherwise return a default (also trimmed).
+ *
+ * Purpose:
+ *  Guarantee that downstream code receives a usable, non-empty string
+ *  without performing implicit type coercion.
+ *
+ * Acceptance Criteria:
+ *  - Accept only actual strings whose `trim()` length is > 0.
+ *  - Return `value.trim()` when valid.
+ *  - Otherwise return `defaultValue.trim()`.
+ *
+ * Why strict for strings?
+ *  - Silent coercion from non-strings to string can hide bugs.
+ *  - If you need to stringify other types, do it explicitly at the call site.
+ *
+ * Edge Cases:
+ *  - If `defaultValue` is empty or whitespace-only, the function returns an empty string.
+ *    Prefer providing a meaningful, non-empty default for clarity.
+ *
+ * @param {any} value
+ *   Candidate to normalize (must be a string to be accepted).
+ * @param {string} defaultValue
+ *   Fallback used when `value` is not a non-empty string. Will be `trim()`ed.
+ * @returns {string}
+ *   A trimmed non-empty string when `value` is valid; otherwise `defaultValue.trim()`.
+ *
+ * @example
+ * normalizeStringOrDefault('  user-roles-management:edit  ', 'fallback')
+ * // → 'user-roles-management:edit'
+ *
+ * @example
+ * normalizeStringOrDefault('', 'user-roles-management:edit')
+ * // → 'user-roles-management:edit'
+ *
+ * @example
+ * normalizeStringOrDefault(42, 'user-roles-management:edit')
+ * // → 'user-roles-management:edit'
+ */
+export function normalizeStringOrDefault(value: any, defaultValue: string): string;
+/**
+ * Normalize a value to a valid number (with safe string coercion); otherwise return a default.
+ *
+ * Purpose:
+ *  Accept numeric inputs that may arrive as strings (e.g., from env vars or config files)
+ *  while keeping semantics explicit and predictable.
+ *
+ * Acceptance Criteria:
+ *  - Accepts finite numbers (`typeof value === 'number' && Number.isFinite(value)`).
+ *  - Accepts strings that become a finite number via `Number(trimmed)`.
+ *    Examples: "42", "  3.14 ", "1e3", "-7", "0x10" (JS Number semantics).
+ *  - Rejects non-numeric strings (e.g., "", "   ", "abc") and non-number types.
+ *  - Returns `defaultValue` when not acceptable.
+ *
+ * Parsing Semantics:
+ *  - Uses `Number(s)` which requires the whole trimmed string to be numeric.
+ *  - Honors JavaScript numeric literal rules (including hex and scientific notation).
+ *  - If you want base-10 only or looser parsing, do it explicitly before calling.
+ *
+ * @param {any} value
+ *   Candidate to normalize (number or numeric string).
+ * @param {number} defaultValue
+ *   Fallback used when `value` is neither a finite number nor a numeric string.
+ * @returns {number}
+ *   A finite number derived from `value`, or `defaultValue`.
+ *
+ * @example
+ * normalizeNumberOrDefault(42, 0)       // → 42
+ * normalizeNumberOrDefault(' 3.14 ', 0) // → 3.14
+ * normalizeNumberOrDefault('1e3', 0)    // → 1000
+ * normalizeNumberOrDefault('-7', 0)     // → -7
+ *
+ * @example
+ * normalizeNumberOrDefault('abc', 7)    // → 7
+ * normalizeNumberOrDefault(NaN, 7)      // → 7
+ * normalizeNumberOrDefault({}, 7)       // → 7
+ */
+export function normalizeNumberOrDefault(value: any, defaultValue: number): number;
+/**
+ * Normalize a value to a boolean (with "true"/"false" string support); otherwise return a default.
+ *
+ * Purpose:
+ *  Stabilize feature flags and binary config values that might be provided as either booleans
+ *  or as canonical strings.
+ *
+ * Acceptance Criteria:
+ *  - Accepts actual booleans (`true` / `false`) → returned as-is.
+ *  - Accepts strings equal to "true" or "false" (case-insensitive, trimmed).
+ *    "true"  → true
+ *    "false" → false
+ *  - Rejects other strings ("yes", "1", "0", etc.) and other types → returns `defaultValue`.
+ *
+ * Rationale:
+ *  - Limiting string forms to the canonical words avoids accidental truthiness/falseyness.
+ *  - If you need to accept "1"/"0" or other variants, coerce at the call site so intent is explicit.
+ *
+ * @param {any} value
+ *   Candidate to normalize (boolean or "true"/"false" string).
+ * @param {boolean} defaultValue
+ *   Fallback used when `value` is neither a boolean nor an accepted string form.
+ * @returns {boolean}
+ *   A boolean derived from `value`, or `defaultValue`.
+ *
+ * @example
+ * normalizeBooleanOrDefault(true,  false) // → true
+ * normalizeBooleanOrDefault(false, true)  // → false
+ *
+ * @example
+ * normalizeBooleanOrDefault('true',  false) // → true
+ * normalizeBooleanOrDefault(' FALSE ', true) // → false
+ *
+ * @example
+ * normalizeBooleanOrDefault('yes',  false) // → false  (rejected → default)
+ * normalizeBooleanOrDefault(1,      true)  // → true   (rejected → default)
+ */
+export function normalizeBooleanOrDefault(value: any, defaultValue: boolean): boolean;

package/types/core/normalize-to-array.d.ts

@@ -0,0 +1 @@
+export function normalizeToArray(value: any): string[];

package/types/core/otp-generators.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Generates a one-time password (OTP) code based on a specified type or character set.
+ *
+ * @param {Object} [options={}] - The options object.
+ * @param {number} [options.length=4] - The desired length of the generated code (1-30).
+ * @param {string} [options.type='numeric'] - The type of characters to use. One of:
+ *  'any', 'alpha', 'numeric', 'symbols', 'alphaLower', 'alphaUpper', 'alphanumeric', 'alphanumericSymbols'.
+ * @param {string} [options.charset] - A custom string of characters to use instead of the predefined types.
+ * @returns {string} The generated code.
+ * @throws {Error} If the length is not a number between 1 and 30.
+ * @throws {Error} If charset is provided and is not a non-empty string.
+ * @throws {Error} If the type is invalid and no valid charset is provided.
+ */
+export function generateCode({ length, type, charset }?: {
+    length?: number;
+    type?: string;
+    charset?: string;
+}): string;
+/**
+ * Generates an OTP code using alphabetic characters (both lowercase and uppercase).
+ *
+ * @param {number} [length=4] - The desired length of the code.
+ * @returns {string} The generated code.
+ */
+export function generateCodeAlpha(length?: number): string;
+/**
+ * Generates an OTP code using only numeric digits (0-9).
+ *
+ * @param {number} [length=4] - The desired length of the code.
+ * @returns {string} The generated code.
+ */
+export function generateCodeDigits(length?: number): string;
+/**
+ * Generates an OTP code using alphabetic characters and digits.
+ *
+ * @param {number} [length=4] - The desired length of the code.
+ * @returns {string} The generated code.
+ */
+export function generateCodeAlphaNumeric(length?: number): string;
+/**
+ * Generates an OTP code using alphabetic characters, digits, and symbols.
+ *
+ * @param {number} [length=4] - The desired length of the code.
+ * @returns {string} The generated code.
+ */
+export function generateCodeAlphaNumericSymbols(length?: number): string;
+export const OTP_GENERATOR_TYPES: Readonly<{
+    any: "any";
+    alpha: "alpha";
+    numeric: "numeric";
+    symbols: "symbols";
+    alphaLower: "alphaLower";
+    alphaUpper: "alphaUpper";
+    alphanumeric: "alphanumeric";
+    alphanumericSymbols: "alphanumericSymbols";
+}>;

package/types/core/regex-utils.d.ts

@@ -0,0 +1 @@
+export function isValidRegex(pattern: string | RegExp): boolean;

package/types/core/sanitize-objects.d.ts

@@ -0,0 +1,4 @@
+export function sanitizeObject(obj: any, filter: (entry: [string, any]) => boolean): any;
+export function sanitizeUndefinedFields(obj: any): any;
+export function sanitizeObjectAllowProps(obj: any, allowedFields?: string[]): any;
+export function sanitizeObjectDisallowProps(obj: any, disallowedFields?: string[]): any;

package/types/crypto/crypto.d.ts

@@ -0,0 +1,18 @@
+export function getSalt(length: number): Buffer;
+export function getSaltHex(length: number): string;
+export function getEncryptedBuffer({ salt, expression, length, }: {
+    expression: string;
+    salt: string;
+    length?: number;
+}): Promise<Buffer>;
+export function encrypt({ salt, expression, passwordPrivateKey }: {
+    expression: string;
+    salt: string;
+    passwordPrivateKey?: string;
+}): Promise<string>;
+export function isPasswordMatch({ salt, password, encryptedPassword, passwordPrivateKey, }: {
+    salt: string;
+    password: string;
+    encryptedPassword: string;
+    passwordPrivateKey?: string;
+}): Promise<boolean>;

package/types/crypto/encryption.d.ts

@@ -0,0 +1,6 @@
+export function encryptPassword({ password }: {
+    password: string;
+}, { saltLength, passwordPrivateKey }: {
+    saltLength: number;
+    passwordPrivateKey?: string;
+}): Promise<any>;

package/types/crypto/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./crypto.js";
+export * from "./encryption.js";

package/types/fastify/error-codes.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A reusable generic error object representing a server-side failure (HTTP 500).
+ * Useful as a fallback error descriptor for unhandled or unexpected failures.
+ *
+ * @typedef {Object} GeneralError
+ * @property {number} httpStatusCode - The HTTP status code (500).
+ * @property {string} httpStatusText - The human-readable status text ("Internal Server Error").
+ * @property {string} code - An application-specific error code in the format "GENERAL.<StatusText>".
+ */
+/** @type {GeneralError} */
+export const GENERAL_ERROR: GeneralError;
+/**
+ * A reusable generic error object representing a server-side failure (HTTP 500).
+ * Useful as a fallback error descriptor for unhandled or unexpected failures.
+ */
+export type GeneralError = {
+    /**
+     * - The HTTP status code (500).
+     */
+    httpStatusCode: number;
+    /**
+     * - The human-readable status text ("Internal Server Error").
+     */
+    httpStatusText: string;
+    /**
+     * - An application-specific error code in the format "GENERAL.<StatusText>".
+     */
+    code: string;
+};

package/types/fastify/error-handlers/with-error-handling.d.ts

@@ -0,0 +1,15 @@
+export function withErrorHandling(log: object, defaultError: HttpError): (funcToInvoke: () => Promise<any>) => Promise<any>;
+export function withErrorHandlingReply({ reply, log, defaultError }: {
+    reply: Reply;
+    log: Logger;
+    defaultError?: HttpError;
+}): (funcToInvoke: any) => Promise<any>;
+export function replyOnErrorOnly({ reply, log, defaultError }: {
+    reply: Reply;
+    log: Logger;
+    defaultError?: HttpError;
+}): (funcToInvoke: any) => Promise<any>;
+export type Reply = import("fastify").FastifyReply;
+export type Request = import("fastify").FastifyRequest;
+export type Logger = import("pino").Logger;
+import { HttpError } from '../../http/HttpError.js';

package/types/fastify/index.d.ts

@@ -0,0 +1,2 @@
+export { GENERAL_ERROR } from "./error-codes.js";
+export * from "./error-handlers/with-error-handling.js";

package/types/http/HttpError.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Represents a custom HTTP error with optional status code, status text, error code, and extra metadata.
+ * Useful for consistent error handling across services.
+ */
+export class HttpError extends Error {
+    /**
+     * Checks if a given object is an instance of `HttpError`.
+     *
+     * @param {*} instance - The object to check.
+     * @returns {boolean} True if `instance` is an instance of `HttpError`.
+     */
+    static isInstanceOf(instance: any): boolean;
+    /**
+     * Checks if the error is an instance of `HttpError` or has similar shape.
+     *
+     * @param {object} error
+     * @returns {error is HttpError}
+     */
+    static isHttpError(error: object): error is HttpError;
+    /**
+     * Creates an HttpError from a generic Error instance or returns it if already an HttpError.
+     *
+     * @param {Error | HttpError} error
+     * @returns {HttpError}
+     */
+    static FromError(error: Error | HttpError): HttpError;
+    /**
+     * Creates an instance of HttpError.
+     *
+     * @param {Object} [error] - Optional error object.
+     * @param {string | number} [error.code] - Application-specific error code.
+     * @param {string} [error.message] - Custom error message.
+     * @param {number} [error.httpStatusCode] - HTTP status code (e.g., 404, 500).
+     * @param {string} [error.httpStatusText] - Optional human-readable HTTP status text.
+     * @param {object} [error.extendInfo] - Optional extended metadata for diagnostics.
+     */
+    constructor(error?: {
+        code?: string | number;
+        message?: string;
+        httpStatusCode?: number;
+        httpStatusText?: string;
+        extendInfo?: object;
+    });
+    /**
+     * @type {string | number | undefined}
+     * A short application-specific error code (e.g., "INVALID_INPUT" or a numeric code).
+     */
+    code: string | number | undefined;
+    /**
+     * @type {number | undefined}
+     * HTTP status code associated with the error (e.g., 400, 500).
+     */
+    httpStatusCode: number | undefined;
+    /**
+     * @type {string | undefined}
+     * Human-readable HTTP status text (e.g., "Bad Request").
+     */
+    httpStatusText: string | undefined;
+    /**
+     * @type {object | undefined}
+     * Optional metadata for debugging/logging (e.g., request ID, user ID, retryAfter).
+     */
+    extendInfo: object | undefined;
+    /**
+     * Converts the error to a plain object (useful for logging or sending as JSON).
+     *
+     * @returns {{
+     *   code: string | number | undefined,
+     *   message: string,
+     *   httpStatusCode: number | undefined,
+     *   httpStatusText: string | undefined,
+     *   extendInfo?: object
+     * }}
+     */
+    toJSON(): {
+        code: string | number | undefined;
+        message: string;
+        httpStatusCode: number | undefined;
+        httpStatusText: string | undefined;
+        extendInfo?: object;
+    };
+}

package/types/http/http-method.d.ts

@@ -0,0 +1,7 @@
+export const HTTP_METHODS: Readonly<{
+    GET: "GET";
+    POST: "POST";
+    PUT: "PUT";
+    PATCH: "PATCH";
+    DELETE: "DELETE";
+}>;

package/types/http/http.d.ts

@@ -0,0 +1,36 @@
+export function get({ url, headers, expectedType, }: {
+    url: any;
+    headers?: {};
+    expectedType?: "json";
+}): Promise<any>;
+export function post({ url, body, headers, expectedType, }: {
+    url: any;
+    body: any;
+    headers?: {};
+    expectedType?: "json";
+}): Promise<any>;
+export function put({ url, body, headers, expectedType, }: {
+    url: any;
+    body: any;
+    headers?: {};
+    expectedType?: "json";
+}): Promise<any>;
+export function patch({ url, body, headers, expectedType, }: {
+    url: any;
+    body: any;
+    headers?: {};
+    expectedType?: "json";
+}): Promise<any>;
+export function deleteApi({ url, body, headers, expectedType, }: {
+    url: any;
+    body: any;
+    headers?: {};
+    expectedType?: "json";
+}): Promise<any>;
+export namespace http {
+    export { get };
+    export { put };
+    export { post };
+    export { patch };
+    export { deleteApi };
+}

package/types/http/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./http.js";
+export * from "./HttpError.js";
+export * from "./http-method.js";
+export * from "./responseType.js";

package/types/http/responseType.d.ts

@@ -0,0 +1,20 @@
+/**
+ * *
+ */
+export type ResponseType = string;
+/**
+ * Enum representing supported response types for HTTP client parsing.
+ *
+ * @readonly
+ * @enum {string}
+ * @property {string} xml  - XML response (parsed using xml2js).
+ * @property {string} json - JSON response (parsed via JSON.parse).
+ * @property {string} text - Plain text response.
+ * @property {string} file - Binary file or blob (not automatically parsed).
+ */
+export const ResponseType: Readonly<{
+    xml: "xml";
+    json: "json";
+    text: "text";
+    file: "file";
+}>;

package/types/ids/generators.d.ts

@@ -0,0 +1,10 @@
+export function generateId(): string;
+export function generatePrefixedId(prefix: string): string;
+export function generateUserId(): string;
+export function generateTenantId(): string;
+export function generatePermissionId(): string;
+export function generateCorrelationId(): string;
+export function generateVerificationId(): string;
+export function generateRolePermissionsId(): string;
+export function generateOnboardingId(): string;
+export function generateSessionId(): string;

package/types/ids/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./prefixes.js";
+export * from "./generators.js";

package/types/ids/prefixes.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Mapping of entity types to their unique ID prefixes.
+ *
+ * These prefixes are prepended to ULIDs to create consistent and identifiable IDs across the system.
+ * For example: 'usr_01HZY3M7K4FJ9A8Q4Y1ZB5NX3T'
+ */
+export type ID_PREFIXES = string;
+/**
+ * Mapping of entity types to their unique ID prefixes.
+ *
+ * These prefixes are prepended to ULIDs to create consistent and identifiable IDs across the system.
+ * For example: 'usr_01HZY3M7K4FJ9A8Q4Y1ZB5NX3T'
+ *
+ * @readonly
+ * @enum {string}
+ */
+export const ID_PREFIXES: Readonly<{
+    /** User entity ID prefix */
+    USER: "usr";
+    /** Tenant entity ID prefix */
+    TENANT: "tnt";
+    /** Permission entity ID prefix */
+    PERMISSION: "prm";
+    /** Correlation ID prefix (e.g., for tracing requests) */
+    CORRELATION: "crln";
+    /** Verification entity ID prefix (e.g., email/phone code) */
+    VERIFICATION: "vrf";
+    /** Role-permissions mapping ID prefix */
+    ROLE_PERMISSIONS: "role";
+    /** Onboarding mapping ID prefix */
+    ONBOARDING: "onb";
+    /** Session mapping ID prefix */
+    SESSION: "sess";
+}>;

package/types/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./core/index.js";
+export * from "./crypto/index.js";
+export * from "./fastify/index.js";
+export * from "./http/index.js";
+export * from "./ids/index.js";
+export * from "./mongodb/index.js";
+export * from "./logger/index.js";
+export * from "./mailer/index.js";
+export * from "./rabbit-mq/index.js";
+export * from "./templates/index.js";
+export * from "./util/index.js";

package/types/logger/get-logger.d.ts

@@ -0,0 +1,23 @@
+export function getLogger(option: true | any | undefined): import("pino").Logger | typeof dummyLogger;
+declare namespace dummyLogger {
+    function info(): void;
+    function warn(): void;
+    function trace(): void;
+    function debug(): void;
+    function error(): void;
+    function fatal(): void;
+    function levels(): void;
+    function silent(): void;
+    function child(): {
+        info: () => void;
+        warn: () => void;
+        trace: () => void;
+        debug: () => void;
+        error: () => void;
+        fatal: () => void;
+        levels: () => void;
+        silent: () => void;
+        child(): /*elided*/ any;
+    };
+}
+export {};

package/types/logger/index.d.ts

@@ -0,0 +1 @@
+export * from "./get-logger.js";

package/types/mailer/index.d.ts

@@ -0,0 +1,2 @@
+export function initMailer(config: any): Mailer;
+import { Mailer } from './mailer.service.js';

package/types/mailer/mailer.service.d.ts

@@ -0,0 +1,21 @@
+export class Mailer {
+    /**
+     * @param {object} transporter - Nodemailer transporter instance
+     */
+    constructor(transporter: object);
+    transporter: any;
+    /**
+     * Send an email
+     */
+    send({ to, subject, html, text, from, cc, bcc, replyTo, attachments }: {
+        to: any;
+        subject: any;
+        html: any;
+        text: any;
+        from: any;
+        cc: any;
+        bcc: any;
+        replyTo: any;
+        attachments: any;
+    }): Promise<any>;
+}

package/types/mailer/transport.factory.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Factory for creating email transporters based on configuration.
+ */
+export class TransportFactory {
+    /**
+     * Create a Nodemailer transporter
+     *
+     * @param {object} config - Transport configuration object
+     * @param {'smtp' | 'gmail' | 'sendgrid' | 'ses'} config.type - Type of email transport
+     *
+     * For type 'smtp':
+     * @param {string} config.host - SMTP server host
+     * @param {number} config.port - SMTP server port
+     * @param {boolean} config.secure - Use TLS
+     * @param {{ user: string, pass: string }} config.auth - SMTP auth credentials
+     *
+     * For type 'gmail':
+     * @param {{ user: string, pass: string }} config.auth - Gmail credentials
+     *
+     * For type 'sendgrid':
+     * @param {string} config.apiKey - SendGrid API key
+     *
+     * For type 'ses':
+     * @param {string} config.accessKeyId - AWS access key
+     * @param {string} config.secretAccessKey - AWS secret
+     * @param {string} config.region - AWS region
+     *
+     * @returns {import('nodemailer').Transporter | typeof import('@sendgrid/mail')}
+     */
+    static create(config: {
+        type: "smtp" | "gmail" | "sendgrid" | "ses";
+        host: string;
+        port: number;
+        secure: boolean;
+        auth: {
+            user: string;
+            pass: string;
+        };
+        auth: {
+            user: string;
+            pass: string;
+        };
+        apiKey: string;
+        accessKeyId: string;
+        secretAccessKey: string;
+        region: string;
+    }): any | typeof import("@sendgrid/mail");
+}

package/types/mongodb/connect.d.ts

@@ -0,0 +1,4 @@
+export function mongoConnect({ uri, serverApi }: {
+    uri: string;
+    serverApi?: object;
+}): Promise<import("mongodb").MongoClient>;

package/types/mongodb/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./connect.js";
+export * from "./initialize-mongodb.js";
+export * from "./validate-mongo-uri.js";

package/types/mongodb/initialize-mongodb.d.ts

@@ -0,0 +1,13 @@
+export function initializeMongoDb({ config, collectionNames }: {
+    config: {
+        uri: string;
+        options: {
+            dbName: string;
+        };
+    };
+    collectionNames: Record<string, string>;
+}): Promise<Record<string, import("mongodb").Collection> & {
+    withTransaction: <T>(action: ({
+        session: import("mongodb").ClientSession;
+    })) => Promise<T>;
+}>;