@devrev/airsync-sdk 2.0.0-beta.0

package/dist/logger/logger.context.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Executes a function within user log context, marking all logs as user-originated.
+ *
+ * Use this to wrap user-provided callback functions (e.g., task handlers, event callbacks).
+ * The context automatically propagates through any async operations within the function,
+ * ensuring that all console.log calls inside are correctly tagged as user logs.
+ *
+ * @template T - The return type of the function
+ * @param fn - The function to execute within user context (can be sync or async)
+ * @returns The result of the function execution
+ *
+ * @example
+ * ```typescript
+ * await runWithUserLogContext(async () => {
+ *   console.log('This is a user log');  // is_sdk_log: false
+ *   await someAsyncOperation();
+ *   console.log('Still a user log');    // is_sdk_log: false (context preserved)
+ * });
+ * ```
+ */
+export declare function runWithUserLogContext<T>(fn: () => T): T;
+/**
+ * Executes a function within SDK log context, marking all logs as SDK-originated.
+ *
+ * Use this to wrap SDK internal operations (e.g., emit, postState, adapter methods).
+ * The context automatically propagates through any async operations within the function,
+ * ensuring that all console.log calls inside are correctly tagged as SDK logs.
+ *
+ * This allows proper nesting: SDK code can call user code via runWithUserLogContext,
+ * and when control returns to SDK code, logs are correctly attributed.
+ *
+ * @template T - The return type of the function
+ * @param fn - The function to execute within SDK context (can be sync or async)
+ * @returns The result of the function execution
+ *
+ * @example
+ * ```typescript
+ * await runWithSdkLogContext(async () => {
+ *   console.log('SDK internal log');     // is_sdk_log: true
+ *   runWithUserLogContext(() => {
+ *     console.log('User handler log');   // is_sdk_log: false
+ *   });
+ *   console.log('Back to SDK log');      // is_sdk_log: true
+ * });
+ * ```
+ */
+export declare function runWithSdkLogContext<T>(fn: () => T): T;
+/**
+ * Retrieves the current SDK log context value.
+ *
+ * Returns whether the current execution context is within SDK code (true) or user code (false).
+ * If no context has been set (e.g., during testing or edge cases), returns the provided default.
+ *
+ * @param defaultValue - The value to return if no context is currently set
+ * @returns `true` if in SDK context, `false` if in user context, or defaultValue if unset
+ */
+export declare function getSdkLogContextValue(defaultValue: boolean): boolean;
+//# sourceMappingURL=logger.context.d.ts.map

package/dist/logger/logger.context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.context.d.ts","sourceRoot":"","sources":["../../src/logger/logger.context.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAEvD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAEtD;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,OAAO,GAAG,OAAO,CAMpE"}

package/dist/logger/logger.context.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWithUserLogContext = runWithUserLogContext;
+exports.runWithSdkLogContext = runWithSdkLogContext;
+exports.getSdkLogContextValue = getSdkLogContextValue;
+const node_async_hooks_1 = require("node:async_hooks");
+/**
+ * Async-aware context storage for tracking whether code is executing within SDK or user context.
+ *
+ * AsyncLocalStorage is used instead of a simple global variable because it automatically
+ * propagates the context across async boundaries (await, Promise.then, setTimeout, etc.).
+ * This ensures that even after multiple await calls in user code, the logging context
+ * remains correct without requiring explicit context passing through function parameters.
+ *
+ * The stored boolean value indicates:
+ * - `true`: Code is executing within SDK internals (logs tagged as is_sdk_log: true)
+ * - `false`: Code is executing within user-provided handlers (logs tagged as is_sdk_log: false)
+ */
+const sdkLogContext = new node_async_hooks_1.AsyncLocalStorage();
+/**
+ * Executes a function within user log context, marking all logs as user-originated.
+ *
+ * Use this to wrap user-provided callback functions (e.g., task handlers, event callbacks).
+ * The context automatically propagates through any async operations within the function,
+ * ensuring that all console.log calls inside are correctly tagged as user logs.
+ *
+ * @template T - The return type of the function
+ * @param fn - The function to execute within user context (can be sync or async)
+ * @returns The result of the function execution
+ *
+ * @example
+ * ```typescript
+ * await runWithUserLogContext(async () => {
+ *   console.log('This is a user log');  // is_sdk_log: false
+ *   await someAsyncOperation();
+ *   console.log('Still a user log');    // is_sdk_log: false (context preserved)
+ * });
+ * ```
+ */
+function runWithUserLogContext(fn) {
+    return sdkLogContext.run(false, fn);
+}
+/**
+ * Executes a function within SDK log context, marking all logs as SDK-originated.
+ *
+ * Use this to wrap SDK internal operations (e.g., emit, postState, adapter methods).
+ * The context automatically propagates through any async operations within the function,
+ * ensuring that all console.log calls inside are correctly tagged as SDK logs.
+ *
+ * This allows proper nesting: SDK code can call user code via runWithUserLogContext,
+ * and when control returns to SDK code, logs are correctly attributed.
+ *
+ * @template T - The return type of the function
+ * @param fn - The function to execute within SDK context (can be sync or async)
+ * @returns The result of the function execution
+ *
+ * @example
+ * ```typescript
+ * await runWithSdkLogContext(async () => {
+ *   console.log('SDK internal log');     // is_sdk_log: true
+ *   runWithUserLogContext(() => {
+ *     console.log('User handler log');   // is_sdk_log: false
+ *   });
+ *   console.log('Back to SDK log');      // is_sdk_log: true
+ * });
+ * ```
+ */
+function runWithSdkLogContext(fn) {
+    return sdkLogContext.run(true, fn);
+}
+/**
+ * Retrieves the current SDK log context value.
+ *
+ * Returns whether the current execution context is within SDK code (true) or user code (false).
+ * If no context has been set (e.g., during testing or edge cases), returns the provided default.
+ *
+ * @param defaultValue - The value to return if no context is currently set
+ * @returns `true` if in SDK context, `false` if in user context, or defaultValue if unset
+ */
+function getSdkLogContextValue(defaultValue) {
+    const storeValue = sdkLogContext.getStore();
+    if (typeof storeValue === 'boolean') {
+        return storeValue;
+    }
+    return defaultValue;
+}

package/dist/logger/logger.d.ts

@@ -0,0 +1,89 @@
+import { AxiosError } from 'axios';
+import { Console } from 'node:console';
+import { AxiosErrorResponse, LoggerFactoryInterface, LogLevel, PrintableState } from './logger.interfaces';
+/**
+ * Custom logger that extends Node.js Console with context-aware logging.
+ * Handles local development, main thread, and worker thread logging differently.
+ */
+export declare class Logger extends Console {
+    private originalConsole;
+    private options?;
+    private tags;
+    constructor({ event, options }: LoggerFactoryInterface);
+    /**
+     * Converts any value to a string using `util.inspect()` for complex types.
+     *
+     * @param value - The value to convert
+     * @returns String representation of the value
+     */
+    private valueToString;
+    /**
+     * Truncates a message if it exceeds the maximum allowed length.
+     * Adds a suffix indicating how many characters were omitted.
+     *
+     * @param message - The message to truncate
+     * @returns Truncated message or original if within limits
+     */
+    private truncateMessage;
+    /**
+     * Logs a pre-formatted message string to the console.
+     * In production mode, wraps the message with JSON formatting and event context tags.
+     * In local development mode, logs the message directly without JSON wrapping.
+     * This is useful when you need to log already-stringified content.
+     *
+     * @param message - The pre-formatted message string to log
+     * @param level - Log level (info, warn, error)
+     * @param isSdkLog - Flag indicating if the log originated from the SDK
+     */
+    logFn(message: string, level: LogLevel, isSdkLog?: boolean): void;
+    /**
+     * Stringifies and logs arguments to the appropriate destination.
+     * On main thread, converts arguments to strings and calls logFn.
+     * In worker threads, forwards stringified arguments to the main thread for processing.
+     * All arguments are converted to strings using util.inspect and joined with spaces.
+     *
+     * @param args - Values to log (will be stringified and truncated if needed)
+     * @param level - Log level (info, warn, error)
+     */
+    private stringifyAndLog;
+    log(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+/**
+ * Converts a state object into a printable format where arrays are summarized.
+ * Arrays show their length, first item, and last item instead of all elements.
+ * Objects are recursively processed and primitives are returned as-is.
+ *
+ * @param state - State object to convert
+ * @returns Printable representation with summarized arrays
+ */
+export declare function getPrintableState(state: Record<string, any>): PrintableState;
+/**
+ * Serializes an error into a structured format.
+ * Automatically detects and formats Axios errors with HTTP details.
+ * Returns other error types as-is.
+ *
+ * @param error - Error to serialize
+ * @returns Serialized error or original if not an Axios error
+ */
+export declare function serializeError(error: unknown): unknown;
+/**
+ * Serializes an Axios error into a structured format with HTTP request/response details.
+ * Extracts method, URL, parameters, status code, headers, and data.
+ * Includes CORS/network failure indicator when no response is available.
+ *
+ * @param error - Axios error to serialize
+ * @returns Structured object with error details
+ */
+export declare function serializeAxiosError(error: AxiosError): AxiosErrorResponse;
+/**
+ * Formats an Axios error to a printable format.
+ *
+ * @param error - Axios error to format
+ * @returns Formatted error object
+ * @deprecated Use {@link serializeAxiosError} instead
+ */
+export declare function formatAxiosError(error: AxiosError): object;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/logger/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAyC,MAAM,OAAO,CAAC;AAE1E,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AASvC,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EAEtB,QAAQ,EAER,cAAc,EACf,MAAM,qBAAqB,CAAC;AAE7B;;;GAGG;AACH,qBAAa,MAAO,SAAQ,OAAO;IACjC,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,OAAO,CAAC,CAAuB;IACvC,OAAO,CAAC,IAAI,CAAa;gBAEb,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,sBAAsB;IAWtD;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAOrB;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IASvB;;;;;;;;;OASG;IACH,KAAK,CACH,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,QAAQ,EACf,QAAQ,GAAE,OAAqC,GAC9C,IAAI;IAcP;;;;;;;;OAQG;IACH,OAAO,CAAC,eAAe;IAgBd,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAI7B,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAI9B,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAI9B,KAAK,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;CAGzC;AACD;;;;;;;GAOG;AAEH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,cAAc,CAqB5E;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAKtD;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,kBAAkB,CAwBzE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAE1D"}

package/dist/logger/logger.interfaces.d.ts

@@ -0,0 +1,43 @@
+import type { RawAxiosResponseHeaders } from 'axios';
+import type { AirdropEvent, EventContext } from '../types/extraction';
+import type { WorkerAdapterOptions } from '../types/workers';
+export interface LoggerFactoryInterface {
+    event: AirdropEvent;
+    options?: WorkerAdapterOptions;
+}
+export declare enum LogLevel {
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error"
+}
+export interface PrintableArray {
+    type: 'array';
+    length: number;
+    firstItem?: any;
+    lastItem?: any;
+}
+export interface PrintableState {
+    [key: string]: any | PrintableArray | PrintableState;
+}
+export interface AxiosErrorResponse {
+    config: {
+        method: string | undefined;
+        params: any;
+        url: string | undefined;
+    };
+    isAxiosError: boolean;
+    isCorsOrNoNetworkError: boolean;
+    response?: {
+        data: unknown;
+        headers: RawAxiosResponseHeaders;
+        status: number;
+        statusText: string;
+    };
+    code?: string;
+    message?: string;
+}
+export interface LoggerTags extends EventContext {
+    sdk_version: string;
+    is_sdk_log: boolean;
+}
+//# sourceMappingURL=logger.interfaces.d.ts.map

package/dist/logger/logger.interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.interfaces.d.ts","sourceRoot":"","sources":["../../src/logger/logger.interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,OAAO,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE7D,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAED,oBAAY,QAAQ;IAClB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IAEf,SAAS,CAAC,EAAE,GAAG,CAAC;IAEhB,QAAQ,CAAC,EAAE,GAAG,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAE7B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,cAAc,GAAG,cAAc,CAAC;CACtD;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE;QACN,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;QAE3B,MAAM,EAAE,GAAG,CAAC;QACZ,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;KACzB,CAAC;IACF,YAAY,EAAE,OAAO,CAAC;IACtB,sBAAsB,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,EAAE;QACT,IAAI,EAAE,OAAO,CAAC;QACd,OAAO,EAAE,uBAAuB,CAAC;QACjC,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,UAAW,SAAQ,YAAY;IAC9C,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;CACrB"}

package/dist/logger/logger.interfaces.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["INFO"] = "info";
+    LogLevel["WARN"] = "warn";
+    LogLevel["ERROR"] = "error";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));

package/dist/logger/logger.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+exports.getPrintableState = getPrintableState;
+exports.serializeError = serializeError;
+exports.serializeAxiosError = serializeAxiosError;
+exports.formatAxiosError = formatAxiosError;
+const axios_1 = require("axios");
+const node_console_1 = require("node:console");
+const node_util_1 = require("node:util");
+const node_worker_threads_1 = require("node:worker_threads");
+const constants_1 = require("../common/constants");
+const workers_1 = require("../types/workers");
+const logger_constants_1 = require("./logger.constants");
+const logger_context_1 = require("./logger.context");
+const logger_interfaces_1 = require("./logger.interfaces");
+/**
+ * Custom logger that extends Node.js Console with context-aware logging.
+ * Handles local development, main thread, and worker thread logging differently.
+ */
+class Logger extends node_console_1.Console {
+    constructor({ event, options }) {
+        super(process.stdout, process.stderr);
+        this.originalConsole = console;
+        this.options = options;
+        this.tags = Object.assign(Object.assign({}, event.payload.event_context), { sdk_version: constants_1.LIBRARY_VERSION, is_sdk_log: true });
+    }
+    /**
+     * Converts any value to a string using `util.inspect()` for complex types.
+     *
+     * @param value - The value to convert
+     * @returns String representation of the value
+     */
+    valueToString(value) {
+        if (typeof value === 'string') {
+            return value;
+        }
+        return (0, node_util_1.inspect)(value, logger_constants_1.INSPECT_OPTIONS);
+    }
+    /**
+     * Truncates a message if it exceeds the maximum allowed length.
+     * Adds a suffix indicating how many characters were omitted.
+     *
+     * @param message - The message to truncate
+     * @returns Truncated message or original if within limits
+     */
+    truncateMessage(message) {
+        if (message.length > logger_constants_1.MAX_LOG_STRING_LENGTH) {
+            return `${message.substring(0, logger_constants_1.MAX_LOG_STRING_LENGTH)}... ${message.length - logger_constants_1.MAX_LOG_STRING_LENGTH} more characters`;
+        }
+        return message;
+    }
+    /**
+     * Logs a pre-formatted message string to the console.
+     * In production mode, wraps the message with JSON formatting and event context tags.
+     * In local development mode, logs the message directly without JSON wrapping.
+     * This is useful when you need to log already-stringified content.
+     *
+     * @param message - The pre-formatted message string to log
+     * @param level - Log level (info, warn, error)
+     * @param isSdkLog - Flag indicating if the log originated from the SDK
+     */
+    logFn(message, level, isSdkLog = (0, logger_context_1.getSdkLogContextValue)(true)) {
+        var _a;
+        if ((_a = this.options) === null || _a === void 0 ? void 0 : _a.isLocalDevelopment) {
+            this.originalConsole[level](message);
+            return;
+        }
+        const logObject = Object.assign(Object.assign({ message }, this.tags), { is_sdk_log: isSdkLog });
+        this.originalConsole[level](JSON.stringify(logObject));
+    }
+    /**
+     * Stringifies and logs arguments to the appropriate destination.
+     * On main thread, converts arguments to strings and calls logFn.
+     * In worker threads, forwards stringified arguments to the main thread for processing.
+     * All arguments are converted to strings using util.inspect and joined with spaces.
+     *
+     * @param args - Values to log (will be stringified and truncated if needed)
+     * @param level - Log level (info, warn, error)
+     */
+    stringifyAndLog(args, level) {
+        let stringifiedArgs = args.map((arg) => this.valueToString(arg)).join(' ');
+        stringifiedArgs = this.truncateMessage(stringifiedArgs);
+        const isSdkLog = (0, logger_context_1.getSdkLogContextValue)(true);
+        if (node_worker_threads_1.isMainThread) {
+            this.logFn(stringifiedArgs, level, isSdkLog);
+        }
+        else {
+            node_worker_threads_1.parentPort === null || node_worker_threads_1.parentPort === void 0 ? void 0 : node_worker_threads_1.parentPort.postMessage({
+                subject: workers_1.WorkerMessageSubject.WorkerMessageLog,
+                payload: { stringifiedArgs, level, isSdkLog },
+            });
+        }
+    }
+    log(...args) {
+        this.stringifyAndLog(args, logger_interfaces_1.LogLevel.INFO);
+    }
+    info(...args) {
+        this.stringifyAndLog(args, logger_interfaces_1.LogLevel.INFO);
+    }
+    warn(...args) {
+        this.stringifyAndLog(args, logger_interfaces_1.LogLevel.WARN);
+    }
+    error(...args) {
+        this.stringifyAndLog(args, logger_interfaces_1.LogLevel.ERROR);
+    }
+}
+exports.Logger = Logger;
+/**
+ * Converts a state object into a printable format where arrays are summarized.
+ * Arrays show their length, first item, and last item instead of all elements.
+ * Objects are recursively processed and primitives are returned as-is.
+ *
+ * @param state - State object to convert
+ * @returns Printable representation with summarized arrays
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getPrintableState(state) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function processValue(value) {
+        if (Array.isArray(value)) {
+            return {
+                type: 'array',
+                length: value.length,
+                firstItem: value.length > 0 ? value[0] : undefined,
+                lastItem: value.length > 1 ? value[value.length - 1] : undefined,
+            };
+        }
+        else if (typeof value === 'object' && value !== null) {
+            const processedObject = {};
+            for (const key in value) {
+                processedObject[key] = processValue(value[key]);
+            }
+            return processedObject;
+        }
+        return value;
+    }
+    return processValue(state);
+}
+/**
+ * Serializes an error into a structured format.
+ * Automatically detects and formats Axios errors with HTTP details.
+ * Returns other error types as-is.
+ *
+ * @param error - Error to serialize
+ * @returns Serialized error or original if not an Axios error
+ */
+function serializeError(error) {
+    if ((0, axios_1.isAxiosError)(error)) {
+        return serializeAxiosError(error);
+    }
+    return error;
+}
+/**
+ * Serializes an Axios error into a structured format with HTTP request/response details.
+ * Extracts method, URL, parameters, status code, headers, and data.
+ * Includes CORS/network failure indicator when no response is available.
+ *
+ * @param error - Axios error to serialize
+ * @returns Structured object with error details
+ */
+function serializeAxiosError(error) {
+    var _a, _b, _c;
+    const serializedAxiosError = {
+        config: {
+            method: (_a = error.config) === null || _a === void 0 ? void 0 : _a.method,
+            params: (_b = error.config) === null || _b === void 0 ? void 0 : _b.params,
+            url: (_c = error.config) === null || _c === void 0 ? void 0 : _c.url,
+        },
+        isAxiosError: true,
+        isCorsOrNoNetworkError: !error.response,
+    };
+    if (error.response) {
+        serializedAxiosError.response = {
+            data: error.response.data,
+            headers: error.response.headers,
+            status: error.response.status,
+            statusText: error.response.statusText,
+        };
+    }
+    else {
+        serializedAxiosError.code = error.code;
+        serializedAxiosError.message = error.message;
+    }
+    return serializedAxiosError;
+}
+/**
+ * Formats an Axios error to a printable format.
+ *
+ * @param error - Axios error to format
+ * @returns Formatted error object
+ * @deprecated Use {@link serializeAxiosError} instead
+ */
+function formatAxiosError(error) {
+    return serializeAxiosError(error);
+}

package/dist/logger/logger.test.d.ts

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

package/dist/logger/logger.test.d.ts.map

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