@app-connect/core 1.7.36 → 1.7.38

package/dist/lib/callLogLookup.d.ts

@@ -0,0 +1,6 @@
+import type { BuildCallLogSessionWhereParams, CallLogLookupInput, PersistedCallLogIdentity } from '../types';
+declare function getCallLogExtensionNumber(incomingData: CallLogLookupInput): string;
+declare function getCallLogHashedExtensionId(incomingData: CallLogLookupInput, hashKey?: string): string;
+declare function buildCallLogSessionWhere({ sessionId, sessionIds, extensionNumber, hashedExtensionId }: BuildCallLogSessionWhereParams): Record<string | symbol, unknown>;
+declare function findMatchingCallLog(callLogs: PersistedCallLogIdentity[], sessionId: string, extensionNumber: string | number | null | undefined, hashedExtensionId: string | number | null | undefined): PersistedCallLogIdentity | undefined;
+export { buildCallLogSessionWhere, findMatchingCallLog, getCallLogExtensionNumber, getCallLogHashedExtensionId };

package/{lib → dist/lib}/callLogLookup.js

@@ -1,28 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCallLogSessionWhere = buildCallLogSessionWhere;
+exports.findMatchingCallLog = findMatchingCallLog;
+exports.getCallLogExtensionNumber = getCallLogExtensionNumber;
+exports.getCallLogHashedExtensionId = getCallLogHashedExtensionId;
 const Op = require('sequelize').Op;
 const { getHashValue } = require('./util');
-
 function stringOrEmpty(value) {
     return value == null ? '' : value.toString();
 }
-
 function getCallLogExtensionNumber(incomingData) {
     return stringOrEmpty(incomingData?.extensionNumber ?? incomingData?.logInfo?.extensionNumber);
 }
-
 function getCallLogHashedExtensionId(incomingData, hashKey = process.env.HASH_KEY) {
     const hashedExtensionId = incomingData?.hashedExtensionId ?? incomingData?.logInfo?.hashedExtensionId;
     if (hashedExtensionId) {
         return hashedExtensionId.toString();
     }
-
     const rcExtensionId = incomingData?.rcExtensionId ?? incomingData?.logInfo?.rcExtensionId;
     if (rcExtensionId && hashKey) {
         return getHashValue(rcExtensionId.toString(), hashKey);
     }
-
     return '';
 }
-
 function buildLegacyIdentityWhere(extensionNumberValue) {
     return {
         extensionNumber: extensionNumberValue,
@@ -32,7 +32,6 @@ function buildLegacyIdentityWhere(extensionNumberValue) {
         ],
     };
 }
-
 function buildCallLogSessionWhere({ sessionId, sessionIds, extensionNumber, hashedExtensionId }) {
     const where = {};
     if (sessionIds) {
@@ -43,10 +42,8 @@ function buildCallLogSessionWhere({ sessionId, sessionIds, extensionNumber, hash
     else {
         where.sessionId = sessionId;
     }
-
     const extensionNumberValue = stringOrEmpty(extensionNumber);
     const hashedExtensionIdValue = stringOrEmpty(hashedExtensionId);
-
     if (hashedExtensionIdValue) {
         const identityWhere = [
             { hashedExtensionId: hashedExtensionIdValue },
@@ -62,46 +59,27 @@ function buildCallLogSessionWhere({ sessionId, sessionIds, extensionNumber, hash
     }
     return where;
 }
-
 function hasEmptyHashedExtensionId(callLog) {
     return !stringOrEmpty(callLog.hashedExtensionId);
 }
-
 function findMatchingCallLog(callLogs, sessionId, extensionNumber, hashedExtensionId) {
     const extensionNumberValue = stringOrEmpty(extensionNumber);
     const hashedExtensionIdValue = stringOrEmpty(hashedExtensionId);
     const sessionLogs = callLogs.filter(callLog => callLog.sessionId === sessionId);
-
     if (hashedExtensionIdValue) {
-        const exactHashedLog = sessionLogs.find(callLog => (
-            stringOrEmpty(callLog.hashedExtensionId) === hashedExtensionIdValue
-        ));
+        const exactHashedLog = sessionLogs.find(callLog => (stringOrEmpty(callLog.hashedExtensionId) === hashedExtensionIdValue));
         if (exactHashedLog) {
             return exactHashedLog;
         }
-
         if (extensionNumberValue) {
-            const legacyExtensionLog = sessionLogs.find(callLog => (
-                hasEmptyHashedExtensionId(callLog) &&
-                stringOrEmpty(callLog.extensionNumber) === extensionNumberValue
-            ));
+            const legacyExtensionLog = sessionLogs.find(callLog => (hasEmptyHashedExtensionId(callLog) &&
+                stringOrEmpty(callLog.extensionNumber) === extensionNumberValue));
             if (legacyExtensionLog) {
                 return legacyExtensionLog;
             }
         }
-
-        return sessionLogs.find(callLog => (
-            hasEmptyHashedExtensionId(callLog) &&
-            !stringOrEmpty(callLog.extensionNumber)
-        ));
+        return sessionLogs.find(callLog => (hasEmptyHashedExtensionId(callLog) &&
+            !stringOrEmpty(callLog.extensionNumber)));
     }
-
-    return sessionLogs.find(callLog => (
-        !extensionNumberValue || stringOrEmpty(callLog.extensionNumber) === extensionNumberValue
-    ));
+    return sessionLogs.find(callLog => (!extensionNumberValue || stringOrEmpty(callLog.extensionNumber) === extensionNumberValue));
 }
-
-exports.getCallLogExtensionNumber = getCallLogExtensionNumber;
-exports.getCallLogHashedExtensionId = getCallLogHashedExtensionId;
-exports.buildCallLogSessionWhere = buildCallLogSessionWhere;
-exports.findMatchingCallLog = findMatchingCallLog;

package/dist/lib/constants.d.ts

@@ -0,0 +1,6 @@
+declare const LOG_DETAILS_FORMAT_TYPE: {
+    readonly PLAIN_TEXT: "text/plain";
+    readonly HTML: "text/html";
+    readonly MARKDOWN: "text/markdown";
+};
+export { LOG_DETAILS_FORMAT_TYPE };

package/dist/lib/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_DETAILS_FORMAT_TYPE = void 0;
+const LOG_DETAILS_FORMAT_TYPE = {
+    PLAIN_TEXT: 'text/plain',
+    HTML: 'text/html',
+    MARKDOWN: 'text/markdown'
+};
+exports.LOG_DETAILS_FORMAT_TYPE = LOG_DETAILS_FORMAT_TYPE;

package/dist/lib/debugTracer.d.ts

@@ -0,0 +1,17 @@
+import type { DebugTraceData, RequestWithHeaders, TraceActionSummary, TraceEntry, TraceOptions } from '../types';
+declare class DebugTracer {
+    traces: TraceEntry[];
+    startTime: number;
+    requestId: string;
+    constructor(headers?: Record<string, unknown>);
+    _generateRequestId(): string;
+    _captureStackTrace(skipFrames?: number): string[];
+    trace(methodName: string, data?: unknown, options?: TraceOptions): DebugTracer;
+    traceError(methodName: string, error: Error | string, additionalData?: Record<string, unknown>): DebugTracer;
+    _sanitizeData(data: unknown): unknown;
+    _buildActionSummary(): TraceActionSummary[];
+    getTraceData(): DebugTraceData;
+    wrapResponse(response: Record<string, unknown>): Record<string, unknown>;
+    static fromRequest(req: RequestWithHeaders): DebugTracer;
+}
+export { DebugTracer };

package/{lib → dist/lib}/debugTracer.js

@@ -1,46 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugTracer = void 0;
 class DebugTracer {
-    /**
-     * Creates a new DebugTracer instance
-     * @param {Object} headers - Request headers object
-     */
     constructor(headers = {}) {
         this.traces = [];
         this.startTime = Date.now();
         this.requestId = this._generateRequestId();
     }
-
-    /**
-     * Generates a unique request ID for tracking
-     * @returns {string} Unique request ID
-     */
     _generateRequestId() {
         return `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
     }
-
-    /**
-     * Captures the current stack trace
-     * @param {number} skipFrames - Number of frames to skip from the top (default: 2)
-     * @returns {string[]} Array of stack trace lines
-     */
     _captureStackTrace(skipFrames = 2) {
         const err = new Error();
         const stack = err.stack || '';
         const lines = stack.split('\n').slice(skipFrames);
         return lines.map(line => line.trim()).filter(line => line.startsWith('at '));
     }
-
-    /**
-     * Records a trace entry with method name, data, and stack trace
-     * @param {string} methodName - Name of the method/function being traced
-     * @param {Object} data - Data to record (will be sanitized to remove sensitive info)
-     * @param {Object} options - Additional options
-     * @param {boolean} options.includeStack - Whether to include stack trace (default: true)
-     * @param {string} options.level - Log level: 'info', 'warn', 'error' (default: 'info')
-     * @returns {DebugTracer} Returns this for chaining
-     */
     trace(methodName, data = {}, options = {}) {
         const { includeStack = true, level = 'info' } = options;
-
         const traceEntry = {
             timestamp: new Date().toISOString(),
             elapsed: Date.now() - this.startTime,
@@ -48,80 +25,47 @@ class DebugTracer {
             level,
             data: this._sanitizeData(data)
         };
-
         if (includeStack) {
             traceEntry.stackTrace = this._captureStackTrace(3);
         }
-
         this.traces.push(traceEntry);
         return this;
     }
-
-    /**
-     * Records an error trace with full stack information
-     * @param {string} methodName - Name of the method where error occurred
-     * @param {Error|string} error - Error object or message
-     * @param {Object} additionalData - Additional context data
-     * @returns {DebugTracer} Returns this for chaining
-     */
     traceError(methodName, error, additionalData = {}) {
         const errorData = {
             message: error instanceof Error ? error.message : String(error),
             errorStack: error instanceof Error ? error.stack : null,
             ...additionalData
         };
-
         return this.trace(methodName, errorData, { level: 'error' });
     }
-
-    /**
-     * Sanitizes data by removing sensitive fields
-     * @param {Object} data - Data to sanitize
-     * @returns {Object} Sanitized data
-     */
     _sanitizeData(data) {
         if (!data || typeof data !== 'object') {
             return data;
         }
-
         const sensitiveFields = [
             'accessToken', 'refreshToken', 'apiKey', 'password',
             'secret', 'token', 'authorization', 'auth', 'key',
             'credential', 'credentials', 'privateKey', 'clientSecret'
         ];
-
         const sanitized = Array.isArray(data) ? [...data] : { ...data };
-
         const sanitizeRecursive = (obj) => {
             if (!obj || typeof obj !== 'object') {
                 return obj;
             }
-
             for (const key of Object.keys(obj)) {
                 const lowerKey = key.toLowerCase();
                 if (sensitiveFields.some(field => lowerKey.includes(field.toLowerCase()))) {
-                    // eslint-disable-next-line no-param-reassign
                     obj[key] = '[REDACTED]';
-                } else if (typeof obj[key] === 'object' && obj[key] !== null) {
-                    // eslint-disable-next-line no-param-reassign
-                    obj[key] = sanitizeRecursive(
-                        Array.isArray(obj[key]) ? [...obj[key]] : { ...obj[key] }
-                    );
+                }
+                else if (typeof obj[key] === 'object' && obj[key] !== null) {
+                    obj[key] = sanitizeRecursive(Array.isArray(obj[key]) ? [...obj[key]] : { ...obj[key] });
                 }
             }
             return obj;
         };
-
         return sanitizeRecursive(sanitized);
     }
-
-    /**
-     * Builds a compact summary of all recorded actions, one entry per trace.
-     * Each entry contains the method name, log level, and elapsed time at the
-     * point the trace was recorded, making it easy to skim what happened without
-     * reading the full trace list.
-     * @returns {string[]} Array of human-readable action summary strings
-     */
     _buildActionSummary() {
         return this.traces.map((t, i) => ({
             index: i + 1,
@@ -131,11 +75,6 @@ class DebugTracer {
             elapsedMs: t.elapsed
         }));
     }
-
-    /**
-     * Gets the complete trace data for inclusion in response
-     * @returns {Object} Trace data object
-     */
     getTraceData() {
         return {
             sum: this._buildActionSummary(),
@@ -145,33 +84,18 @@ class DebugTracer {
             traces: this.traces
         };
     }
-
-    /**
-     * Gets trace data and merges it into a response object
-     * @param {Object} response - Original response object
-     * @returns {Object} Response with debug trace data appended (if debug mode enabled)
-     */
     wrapResponse(response) {
         const traceData = this.getTraceData();
         if (!traceData) {
             return response;
         }
-
         return {
             ...response,
             _debug: traceData
         };
     }
-
-    /**
-     * Static helper to create tracer from Express request
-     * @param {Object} req - Express request object
-     * @returns {DebugTracer} New tracer instance
-     */
     static fromRequest(req) {
         return new DebugTracer(req.headers || {});
     }
 }
-
-module.exports = { DebugTracer };
-
+exports.DebugTracer = DebugTracer;

package/dist/lib/encode.d.ts

@@ -0,0 +1,3 @@
+declare function encode(data: string): string;
+declare function decoded(encryptedData: string): string;
+export { decoded, encode };

package/dist/lib/encode.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoded = decoded;
+exports.encode = encode;
+const crypto = __importStar(require("crypto"));
+function getCipherKey() {
+    if (!process.env.APP_SERVER_SECRET_KEY) {
+        throw new Error('APP_SERVER_SECRET_KEY is not defined');
+    }
+    if (process.env.APP_SERVER_SECRET_KEY.length < 32) {
+        // pad secret key with spaces if it is less than 32 bytes
+        return process.env.APP_SERVER_SECRET_KEY.padEnd(32, ' ');
+    }
+    if (process.env.APP_SERVER_SECRET_KEY.length > 32) {
+        // truncate secret key if it is more than 32 bytes
+        return process.env.APP_SERVER_SECRET_KEY.slice(0, 32);
+    }
+    return process.env.APP_SERVER_SECRET_KEY;
+}
+function encode(data) {
+    const cipher = crypto.createCipheriv('aes-256-cbc', getCipherKey(), Buffer.alloc(16, 0));
+    return cipher.update(data, 'utf8', 'hex') + cipher.final('hex');
+}
+function decoded(encryptedData) {
+    const decipher = crypto.createDecipheriv('aes-256-cbc', getCipherKey(), Buffer.alloc(16, 0));
+    return decipher.update(encryptedData, 'hex', 'utf8') + decipher.final('utf8');
+}

package/dist/lib/errorHandler.d.ts

@@ -0,0 +1,7 @@
+import type { AsyncRouteHandler, ExpressLikeNext, ExpressLikeRequest, ExpressLikeResponse, LoggerContext, OperationFailureResult, ProviderError, ReturnMessage } from '../types';
+declare function handleApiError(error: ProviderError, platform: string, operation: string, additionalContext?: LoggerContext): OperationFailureResult;
+declare function getOperationErrorMessage(operation: string, platform: string): ReturnMessage;
+declare function handleDatabaseError(error: ProviderError, operation: string, context?: LoggerContext): OperationFailureResult;
+declare function asyncHandler(fn: AsyncRouteHandler): AsyncRouteHandler;
+declare function errorMiddleware(err: ProviderError, req: ExpressLikeRequest, res: ExpressLikeResponse, next: ExpressLikeNext): void;
+export { handleApiError, handleDatabaseError, asyncHandler, errorMiddleware, getOperationErrorMessage };

package/dist/lib/errorHandler.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleApiError = handleApiError;
+exports.handleDatabaseError = handleDatabaseError;
+exports.asyncHandler = asyncHandler;
+exports.errorMiddleware = errorMiddleware;
+exports.getOperationErrorMessage = getOperationErrorMessage;
+const logger = require('./logger');
+const errorMessage = require('./generalErrorMessage');
+function handleApiError(error, platform, operation, additionalContext = {}) {
+    const response = error.response;
+    const statusCode = response?.status ?? 'unknown';
+    logger.error(`${operation} failed for platform ${platform}`, {
+        platform,
+        operation,
+        statusCode,
+        errorMessage: error.message,
+        errorStack: error.stack,
+        errorResponse: response?.data,
+        ...additionalContext
+    });
+    if (statusCode === 429) {
+        return {
+            successful: false,
+            returnMessage: errorMessage.rateLimitErrorMessage({ platform }),
+            extraDataTracking: {
+                statusCode
+            }
+        };
+    }
+    const numericStatusCode = Number(statusCode);
+    if (numericStatusCode >= 400 && numericStatusCode < 410) {
+        return {
+            successful: false,
+            returnMessage: errorMessage.authorizationErrorMessage({ platform }),
+            extraDataTracking: {
+                statusCode
+            }
+        };
+    }
+    const defaultErrorMessage = getOperationErrorMessage(operation, platform);
+    return {
+        successful: false,
+        returnMessage: defaultErrorMessage,
+        extraDataTracking: {
+            statusCode
+        }
+    };
+}
+function getOperationErrorMessage(operation, platform) {
+    const operationMessages = {
+        createCallLog: {
+            message: 'Error creating call log',
+            details: ['Please check if your account has permission to CREATE logs.']
+        },
+        updateCallLog: {
+            message: 'Error updating call log',
+            details: [`Please check if the log entity still exists on ${platform} and your account has permission to EDIT logs.`]
+        },
+        getCallLog: {
+            message: 'Error getting call log',
+            details: ['Please check if your account has permission to READ logs.']
+        },
+        createMessageLog: {
+            message: 'Error creating message log',
+            details: ['Please check if your account has permission to CREATE logs.']
+        },
+        updateMessageLog: {
+            message: 'Error updating message log',
+            details: [`Please check if the log entity still exists on ${platform} and your account has permission to EDIT logs.`]
+        },
+        findContact: {
+            message: 'Error finding contact',
+            details: ['Please check if your account has permission to GET contacts.']
+        },
+        createContact: {
+            message: 'Error creating contact',
+            details: ['Please check if your account has permission to CREATE contacts.']
+        },
+        findContactWithName: {
+            message: 'Error searching contacts',
+            details: ['Please check if your account has permission to GET contacts.']
+        },
+        createAppointment: {
+            message: 'Error creating appointment',
+            details: ['Please check if your account has permission to CREATE appointments. or All attendees have email address.']
+        },
+        updateAppointment: {
+            message: 'Error updating appointment',
+            details: [`Please check if the appointment entity still exists on ${platform} and your account has permission to EDIT appointments. or All attendees have email address.`]
+        },
+        getAppointment: {
+            message: 'Error getting appointment',
+            details: ['Please check if your account has permission to GET appointments.']
+        }
+    };
+    const operationInfo = operationMessages[operation] || {
+        message: `Error performing ${operation}`,
+        details: ['Please check if your account has the necessary permissions.']
+    };
+    return {
+        message: operationInfo.message,
+        messageType: 'warning',
+        details: [
+            {
+                title: 'Details',
+                items: operationInfo.details.map((detail, index) => ({
+                    id: index + 1,
+                    type: 'text',
+                    text: detail
+                }))
+            }
+        ],
+        ttl: 5000
+    };
+}
+function handleDatabaseError(error, operation, context = {}) {
+    logger.error(`Database operation failed: ${operation}`, {
+        operation,
+        errorMessage: error.message,
+        errorStack: error.stack,
+        ...context
+    });
+    return {
+        successful: false,
+        returnMessage: {
+            message: 'Database operation failed',
+            messageType: 'warning',
+            ttl: 5000
+        }
+    };
+}
+function asyncHandler(fn) {
+    return (req, res, next) => {
+        Promise.resolve(fn(req, res, next)).catch(next);
+    };
+}
+function errorMiddleware(err, req, res, next) {
+    const platform = req.platform || req.query?.platform || 'unknown';
+    const operation = req.route?.path || 'unknown';
+    logger.error('Request failed', {
+        platform,
+        operation,
+        method: req.method,
+        path: req.path,
+        statusCode: err.statusCode || 500,
+        error: err,
+        correlationId: req.correlationId
+    });
+    const message = process.env.NODE_ENV === 'production'
+        ? 'An internal error occurred'
+        : err.message;
+    res.status(err.statusCode || 500).json({
+        successful: false,
+        returnMessage: {
+            message,
+            messageType: 'error',
+            ttl: 5000
+        }
+    });
+}

package/dist/lib/generalErrorMessage.d.ts

@@ -0,0 +1,7 @@
+import type { ReturnMessage } from '../types';
+interface ErrorMessageParams {
+    platform?: string;
+}
+declare function rateLimitErrorMessage({ platform }: ErrorMessageParams): ReturnMessage;
+declare function authorizationErrorMessage({ platform }: ErrorMessageParams): ReturnMessage;
+export { authorizationErrorMessage, rateLimitErrorMessage };

package/{lib → dist/lib}/generalErrorMessage.js

@@ -1,3 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authorizationErrorMessage = authorizationErrorMessage;
+exports.rateLimitErrorMessage = rateLimitErrorMessage;
 function rateLimitErrorMessage({ platform }) {
     return {
         message: `Rate limit exceeded`,
@@ -15,9 +19,8 @@ function rateLimitErrorMessage({ platform }) {
             }
         ],
         ttl: 5000
-    }
+    };
 }
-
 function authorizationErrorMessage({ platform }) {
     return {
         message: `Authorization error`,
@@ -35,8 +38,5 @@ function authorizationErrorMessage({ platform }) {
             }
         ],
         ttl: 5000
-    }
+    };
 }
-
-exports.rateLimitErrorMessage = rateLimitErrorMessage;
-exports.authorizationErrorMessage = authorizationErrorMessage;

package/dist/lib/jwt.d.ts

@@ -0,0 +1,4 @@
+import type { DecodedJwtPayload, JwtPayloadData } from '../types';
+declare function generateJwt(data: JwtPayloadData): string;
+declare function decodeJwt(token: string): DecodedJwtPayload | null;
+export { decodeJwt, generateJwt };

package/dist/lib/jwt.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeJwt = decodeJwt;
+exports.generateJwt = generateJwt;
+const { sign, verify } = require('jsonwebtoken');
+const logger = require('./logger');
+function generateJwt(data) {
+    return sign(data, process.env.APP_SERVER_SECRET_KEY, { expiresIn: '2w' });
+}
+function decodeJwt(token) {
+    try {
+        return verify(token, process.env.APP_SERVER_SECRET_KEY);
+    }
+    catch (e) {
+        logger.error('Error decoding JWT', { stack: e.stack });
+        return null;
+    }
+}

package/dist/lib/logger.d.ts

@@ -0,0 +1,24 @@
+import type { ApiRequestLogOptions, ChildLogger, DatabaseQueryLogOptions, LoggerContext, LoggerLevelName, LoggerOptions } from '../types';
+declare const LOG_LEVELS: Record<LoggerLevelName, number>;
+declare class Logger {
+    level: number;
+    isProd: boolean;
+    enableColors: boolean;
+    constructor(options?: LoggerOptions);
+    _getLogLevel(levelName: string): number;
+    _shouldLog(level: LoggerLevelName): boolean;
+    _formatMessage(level: LoggerLevelName, message: string, context?: LoggerContext): string;
+    _log(level: LoggerLevelName, message: string, context?: LoggerContext): void;
+    error(message: string, context?: LoggerContext): void;
+    warn(message: string, context?: LoggerContext): void;
+    info(message: string, context?: LoggerContext): void;
+    debug(message: string, context?: LoggerContext): void;
+    child(defaultContext?: LoggerContext): ChildLogger;
+    logApiRequest({ method, url, status, duration, platform, error }: ApiRequestLogOptions): void;
+    logDatabaseQuery({ operation, table, duration, error }: DatabaseQueryLogOptions): void;
+}
+declare const logger: Logger & {
+    Logger: typeof Logger;
+    LOG_LEVELS: typeof LOG_LEVELS;
+};
+export = logger;